﻿using System;
using System.Collections.Generic;
using System.Text;
using Sinacor.Servico.Bovespa.Ordens.BusinessEntity;
using Sinacor.Servico.Bovespa.Ordens.ResourceAccess;
using Sinacor.Infra.Common.Exceptions;
using Sinacor.Infra.Service.ExceptionHandling;
using System.Text.RegularExpressions;
using Sinacor.Servico.Bovespa.Titulo.BusinessLogic;
using Sinacor.Servico.Bovespa.Titulo.ResourceAccess;
using System.ComponentModel;
using Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum;
using Sinacor.Infra.Service.Common;
using System.Data;
using System.Data.Common; //incluido - esertorio - 200804161508 - ref issue ID0003223
using Sinacor.Infra.Service.Validation;
using Sinacor.Infra.Common.Validation;


namespace Sinacor.Servico.Bovespa.Ordens.BusinessLogic
{
    public class Ordem : BaseBusinessLogic
	{
         #region Construtor
        public Ordem()
            : base()
        {

        }
        #endregion

		#region Constantes de Erro
        private const int ERRO_CLIENTENAOENCONTRADO = 109892;// O cliente informado não foi encontrado.
		private const int ERRO_ORDEMFINANCIAMENTOPOP_SITUACAONAOINFORMADA = 103009;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_DATAORDEMINVALIDA = 103010;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_NUMEROORDEMINVALIDO = 103011;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_INVALIDA = 103012;
		private const int ERRO_ORDEMINEXISTENTE = 103007;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_TIPOESTRATEGIAINVALIDA = 103013;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_TITULONAOENCONTRADO = 103014;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_NATUREZAOPERACAOINVALIDA = 103015;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_TIPOMERCADOINVALIDO = 103016;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_CARTEIRAPRIORITARIANAOENCONTRADA = 103017;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_CARTEIRANAOCADASTRADA = 103018;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_VENCIMENTOTERMOINVALIDO = 103019;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_QUANTIDADEINVALIDA = 103020;
		private const int ERRO_ORDEMFINANCIAMENTOPOP_PRECOINVALIDO = 103021;
        private const int ERRO_CONSULTAORDENSNEGOCIOS_DATAPREGAOINVALIDA = 103022;    
        private const int ERRO_ORDEMFINANCIAMENTOPOP_ORDEMABERTAMEGABOLSA = 103054;//A ordem não pode ser alterada pois foi aberta pelo MegaBolsa.
        private const int ERRO_ORDEMFINANCIAMENTOPOP_VALIDADE_NAO_ALTERAVEL = 103055;//Ordem com validade já casada fora do prazo para alteração de suas características e para exclusão.
        private const int ERRO_ORDEMFINANCIAMENTOPOP_PERMISSAONEGADA = 103056;//A ordem não pode ser alterada devido a questões de permissão.
        private const int ERRO_ORDEMFINANCIAMENTOPOP_ORDEMNAOALTERADA = 103057;//A ordem não foi alterada.
        private const int ERRO_ORDEMFINANCIAMENTOPOP_ORDEMNAOINCLUIDA = 103058;//A ordem não foi incluída.

        private const int ERRO_NUMERO_ORDEM_NAO_INFORMADO = 103061;// Número da Ordem deve ser informado.
        private const int ERRO_NUMERO_SUBSEQUENCIA_ORDEM_NAO_INFORMADO = 103062;// Número de sub-sequência da ordem deve ser informado.
        private const int ERRO_DATA_ORDEM_NAO_INFORMADA = 103063;// Data da Ordem deve ser informada.
        private const int ERRO_NATUREZA_OPERACAO_NAO_INFORMADA = 103064;// Natureza de Operação deve ser informada.
        private const int ERRO_TIPO_MERCADO_NAO_INFORMADO = 103065;// Tipo de Mercado deve ser informado.
        private const int ERRO_CODIGO_NEGOCIACAO_NAO_INFORMADO = 103066;// Código de Negociação deve ser informado.
        private const int ERRO_QUANTIDADE_NAO_INFORMADA = 103067;// Quantidade deve ser informada.
        private const int ERRO_PRECO_NAO_INFORMADO = 103068;// Preço deve ser informado.
        private const int ERRO_VENCIMENTO_TERMO_NAO_INFORMADO = 103069;// Vencimento Termo deve ser informado.
        private const int ERRO_DATA_PREGAO_NAO_INFORMADA = 103070;// Data do Pregão deve ser informada.
        private const int ERRO_PESQUISA_SEM_RESULTADO = 103194;//19/02/2008 - corrigido - diogo
        private const int ERRO_JUSTIFICATIVADEVESERINFORMADA = 103048;
        private const int ERRO_JUSTIFICATIVA_NAOEXISTEJUSTIFICATIVAPARAESTAORDEM = 109004;

        private const int ERRO_ORDEM_OBJETOORDEMNULO = 103091;
        private const int ERRO_ORDEM_QUANTIDADENAONULOPARAFINANCIAMENTO = 103092;
        private const int ERRO_ORDEM_QUANTIDADEINVALIDA = 103093;
        private const int ERRO_ORDEM_TITULONAONULOPARAFINANCIAMENTO = 103094;
        private const int ERRO_ORDEM_TITULONULO = 103095;
        private const int ERRO_ORDEM_TITULOALTERADO = 103096;
        private const int ERRO_ORDEM_MERCADONULO = 103097;
        private const int ERRO_ORDEM_VENCIMENTOTERMOINVALIDO = 103098;
        private const int ERRO_ORDEM_VENCIMENTOTERMONULO = 103099;
        private const int ERRO_ORDEM_TITULOINVALIDOPARAMERCADO = 103100;
        private const int ERRO_ORDEM_CODIGOCLIENTENAOINFORMADO = 103101;
        private const int ERRO_ORDEM_CODIGOCLIENTEINVALIDO = 103102;
        private const int ERRO_ORDEM_CLIENTEINVALIDOPARABOLSAINFORMADA = 103103;
        private const int ERRO_ORDEM_CLIENTEALTERADOORDEMADMINCON = 103104;
        private const int ERRO_ORDEM_DIGITOCODIGOCLIENTENULO = 103105;
        private const int ERRO_ORDEM_DIGITOCODIGOCLIENTEINVALIDO = 103106;
        private const int ERRO_ORDEM_CODIGOOPERADORINVALIDO = 103107;
        private const int ERRO_ORDEM_NATUREZAOPERACAONULO = 103108;
        private const int ERRO_ORDEM_NATUREZAOPERACAOALTERADAORDEMADMINCON = 103109;
        private const int ERRO_ORDEM_MERCADOINVALIDOPARAFINANCIAMENTO = 103110;
        private const int ERRO_ORDEM_TIPOLIQUIDACAOINVALIDO = 103111;
        private const int ERRO_ORDEM_NOMECLIENTENULO = 103112;
        private const int ERRO_ORDEM_PRECOTITULOINVALIDO_01 = 103113;
        private const int ERRO_ORDEM_PRECOTITULONULO_01 = 103114;
        private const int ERRO_ORDEM_PRECOTITULOINVALIDO_02 = 103115;
        private const int ERRO_ORDEM_PRECOTITULONULO_02 = 103116;
        private const int ERRO_ORDEM_PRECOTITULONULO_03 = 103117;
        private const int ERRO_ORDEM_PRECOTITULOINVALIDO_03 = 103118;
        private const int ERRO_ORDEM_VALORFINANCIAMENTONULO = 103119;
        private const int ERRO_ORDEM_CARTEIRANULO = 103120;
        private const int ERRO_ORDEM_CARTEIRAINVALIDO = 103121;
        private const int ERRO_ORDEM_DATAVALIDADEINVALIDO = 103122;
        private const int ERRO_ORDEM_DATAVALIDADEMENORDATANEGOCIOCASADO = 103123;
        private const int ERRO_ORDEM_TIPOORDEMNULO = 103124;
        private const int ERRO_ORDEM_TIPOORDEMINVALIDO_01 = 103125;
        private const int ERRO_ORDEM_TIPOORDEMINVALIDO_02 = 103126;
        private const int ERRO_ORDEM_TIPOORDEMINVALIDO_03 = 103127;
        private const int ERRO_ORDEM_BOLSANAOCADASTRADAPARAUSUARIO = 103128;
        private const int ERRO_ORDEM_VENCIMENTOTERMOINVALIDO_02 = 103129;
        private const int ERRO_ORDEM_VENCIMENTOTERMONULO_02 = 103130;
        private const int ERRO_ORDEM_VENCIMENTOTERMOINVALIDO_03 = 103131;
        private const int ERRO_ORDEM_QTDEANEXOSMAIORQTDEORDEM_01 = 103132;
        private const int ERRO_ORDEM_QTDEANEXOSMAIORQTDEORDEM_02 = 103133;
        private const int ERRO_ORDEM_POPINVALIDOCOMADMINCON = 103134;
        private const int ERRO_ORDEM_OPCOESFUTUROFORALOTEPADRAO = 103135;
        private const int ERRO_ORDEM_ORDEMDISTRIBUICAOADMINCONNAOALTERAVEL = 103136;
        private const int ERRO_ORDEM_ORDEMINVALIDA = 103137;
        private const int ERRO_ORDEM_ORDEMEXERCICIOAUTOMATICONAOALTERAVEL = 103138;
        private const int ERRO_ORDEM_ORDEMFINANCIAMENTOPOPNAOALTERAVEL = 103139;
        private const int ERRO_ORDEM_ORDEMFINANCPOPFALHOUALTERACAOCLIENTE = 103140;
        private const int ERRO_ORDEM_ORDEMFINANCPOPFALHOUALTERACAOBOLSA = 103141;
        private const int ERRO_ORDEM_SEMPERMISSAOALTERARCOMVALIDADEPASSADA = 103142;
        private const int ERRO_ORDEM_FALHANARECEPCAO = 103143;
        private const int ERRO_ORDEM_ORDEMEXERCICIOAUTOMATICONAOALTERAVEL_02 = 103144;
        private const int ERRO_ORDEM_ORDEMDISTRIBUICAOADMINCONNAOALTERAVEL_02 = 103145;
        private const int ERRO_ORDEM_ORDEMMEGANAOALTERAMERCADO = 103146;
        private const int ERRO_ORDEM_ORDEMMEGANAOALTERAQUANTIDADE = 103147;
        private const int ERRO_ORDEM_ORDEMMEGANAOALTERATITULO = 103148;
        private const int ERRO_ORDEM_ORDEMMEGANAOALTERANATUREZA = 103149;
        private const int ERRO_ORDEM_ORDEMMEGANAOALTERABOLSA = 103150;
        private const int ERRO_ORDEM_ORDEMMEGANAOALTERADATAVALIDADE = 103151;
        private const int ERRO_ORDEM_ORDEMMEGANAOALTERATIPOORDEM = 103152;
        private const int ERRO_ORDEM_ORDEMADMINCONNAOCANCELAVEL = 103153;
        private const int ERRO_ORDEM_ORDEMEGANAOCANCELAVEL = 103154;
        private const int ERRO_ORDEM_EXERCICIOAUTOMATICONAOCANCELAVEL = 103155;
        private const int ERRO_ORDEM_ORDEMMAEFINANCIAMENTONAOCANCELAVEL = 103156;
        private const int ERRO_ORDEM_SEMPERMISSAOEXCLUIRCOMVALIDADEPASSADA = 103157;
        private const int ERRO_ORDEM_EXERCICIOAUTOMATICONAOCANCELAVEL_02 = 103158;
        private const int ERRO_ORDEM_ORDEMMAEFINANCIAMENTONAOCANCELAVEL_02 = 103159;
        private const int ERRO_ORDEM_ORDEMCASADAFORAVALIDADENAOCANCELAVEL = 103160;
        private const int ERRO_ORDEM_DATAORDEMNAOINFORMADA = 103161;
        private const int ERRO_ORDEM_NUMERONAOINFORMADO = 103162;
        private const int ERRO_ORDEM_NUMEROSEQUENCIANAOINFORMADO = 103163;
        private const int ERRO_ORDEM_INDICADORORDEMADMINCONNAOINFORMADO = 103164;
        private const int ERRO_ORDEM_NUMEROORDEMORIGINALNAOINFORMADO = 103165;
        private const int ERRO_ORDEM_OBSERVACAONAOINFORMADO = 103166; //codigo reservado foi utilizado - esertorio - 200802211754
        private const int ERRO_ORDEM_OBSERVACAOINEXISTENTE = 103167; //codigo reservado foi utilizado - esertorio - 200802211754
        private const int ERRO_ORDEM_SEMPERMISSAOINCLUIRORDEM = 103168; //codigo reservado foi utilizado - esertorio - 200804241754 - ref issue ID0003474
        private const int ERRO_ORDEM_SEMPERMISSAOALTERARORDEM = 103169; //codigo reservado foi utilizado - esertorio - 200804241822 - ref issue ID0003474
        private const int ERRO_ORDEM_SEMPERMISSAOEXCLUIRORDEM = 103170; //incluido - esertorio - 200804241844 - ref issue ID0003474

        //constantes migradas da classe OrdemMegaBolsa junto com o metodo (ValidarDataPregaoPreBoletoOrdem) - esertorio - 200804281453 - ref issue ID0003686
        private const int ERRO_ORDEM_SEMPERMISSAOALTERARORDEMDATAANTERIOR = 103197; //incluida - constante migrada da classe OrdemMegaBolsa - esertorio - 200804281455 - ref issue ID0003686
        private const int ERRO_ORDEM_ORDEMINVALIDADATAPREGAOPREBOLETO = 103041; //incluida - constante migrada da classe OrdemMegaBolsa - esertorio - 200804281455 - ref issue ID0003686
        private const int ERRO_ORDEM_ORDEMSEMMARCACASAMENTO = 103042; //incluida - constante migrada da classe OrdemMegaBolsa - esertorio - 200804281458 - ref issue ID0003686
        private const int ERRO_ORDEM_DATAPREGAOPREBOLETOINVALIDA = 103043; //incluida - constante migrada da classe OrdemMegaBolsa - esertorio - 200804281455 - ref issue ID0003686
        private const int ERRO_ORDEM_DATAMOVIMENTOMAIORDATAVALIDADE = 103071; //incluida - constante migrada da classe OrdemMegaBolsa - esertorio - 200804281455 - ref issue ID0003686

        private const int ERRO_ORDEM_CLIENTEDESATIVADO = 103199; //Cliente desativado. //incluido - esertorio - 200805021527 - ref issue ID0003694

        private const int ERRO_ORDEM_ORDEMFINANCPOPFALHOUALTERACAOOUTROSCAMPOS = 103200; //Ordens de Financiamento/POP não puderam ser alteradas por falha na alteração de outros campos das ordens filhas.  //incluido - esertorio - 200805032130 - ref issue ID0003449

        private const int ERRO_ORDEM_DATAVALIDADENULO = 103203; //Data de validade não informada. //incluido - esertorio - 200805032111 - ref issue ID0004007

        private const int ERRO_ORDEM_DATAPREGAOMENORDATAORDEM = 103204; //Data do pregão menor que a data da ordem!. //incluido - rvaladao - 20080512 11:57 - ref issue ID0004728

        private const int ERRO_ORDEM_ISDISCRICIONARIA = 5857; //IsDiscricionaria não informado. // incluido - Ptruiz.gp - 20081027 11:20 - ref issue ID0003781  

        private const int ERRO_ORDEM_DISTRIBUIDA_CANCELAMENTO = 109018;
        private const int ERRO_ORDEM_DISTRIBUIDA_CANCELAMENTO_2 = 109807;

        #endregion Constantes de Erro

        #region Variaveis auxiliares de validacao

        
        private bool bOrdemMae = true; //usado nas validacoes, inclusao e alteracao
        private bool bOrdemExe = false; //usado na exclusao
        private bool bOrdemFin = false; //usado na alteracao
        private ValidationException validationException = new ValidationException();
        private Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente  pClienteIncluir = null;
        private Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Titulo pTituloIncluir = null;
        private BusinessEntity.Ordem pOrdemNaoAlterada = null;

        #endregion Variaveis auxiliares de validacao

        #region Manutencao de Ordens - Incluir

        /// <summary>
        /// Descricao : Logica de inclusao de ordem normal ou mega-bolsa
        /// Autor : Eduardo Sertorio
        /// Data : 27/12/2007
        /// </summary>
        /// <param name="ordem"
        /// <returns>OrdemResponse : ordem incluida</returns>
        public BusinessEntity.Ordem IncluirOrdem(BusinessEntity.Ordem request)
		{
            //executar
            BusinessEntity.Ordem response = ExecutarIncluirOrdem(request);

            //retornar
            return response;
        }
                
        /// <summary>
        /// Descricao : Valida a inclusao de ordem normal ou mega-bolsa
        /// Autor : Eduardo Sertorio
        /// Data : 27/12/2007
        /// 
        /// Autor: Eduardo Sertorio
        /// Data : 27/02/2008
        /// Obs. : Revisao - precisa validar ValidarInAdminCon antes de ValidarCdcliente.
        /// </summary>
        /// <param name="ordemValidar">ordem para incluir</param>
        /// <returns>sem retorno</returns>
        private bool ValidarIncluirOrdem(BusinessEntity.Ordem ordemValidar) 
        {
            if (ordemValidar == null)
                throw new BusinessException(ERRO_ORDEM_OBJETOORDEMNULO); //"Objeto ordem nao pode estar nulo."

            //If sAtributo = 'Nrqtdord'
            ValidarNrqtdord(ordemValidar); // < Quantidade >
          
            //Else If sAtributo = 'Cdnegsp'
            ValidarCdnegsp(ordemValidar); //Titulo            

            //teste : é preciso validar InAdminCon antes de Cdcliente, pois Cdcliente precisa de InAdminCon - eduardo sertorio - 200802271726
            ValidarInAdminCon(ordemValidar); //Checkbox Admincon 
           
            //Else If sAtributo = 'Cdcliente'
            ValidarCdcliente(ordemValidar); //Codigo do cliente do apelido
           
            //Else If sAtributo = 'Dvcliente'
            ValidarDvcliente(ordemValidar); //Digito verificador do cliente
           
            //Else If sAtributo = 'Cdcodusu'
            ValidarCdOperador(ordemValidar); //codigo do operador conectado ou do operador selecionado se o conectador for ponta de mesa
           
            //Else If sAtributo = 'Cdnatope'
            ValidarCdnatope(ordemValidar); //Natureza
           
            //Else If sAtributo = 'Cdmercad'
            ValidarCdmercad(ordemValidar); //Mercado
                       
            //Else If sAtributo = 'Nmcliente'
            ValidarNmcliente(ordemValidar); //Nome cliente
           
            //Else If sAtributo = 'Pcredacr'
            ValidarPcredacr(ordemValidar); //Percentual reducao/acrescimo
           
            //Else If sAtributo = 'Vlprepap'
            ValidarVlprepap(ordemValidar); //Preço
           
            //Else If sAtributo = 'VlFinanc'
            ValidarVlFinanc(ordemValidar); //Valore
           
            //Else If sAtributo = 'Cdcarliq'
            ValidarCdcarliq(ordemValidar); //Carteira
           
            //Else If sAtributo = 'Inliquida'
            ValidarInliquida(ordemValidar); //TP.Liq
           
            //Else If sAtributo = 'Dtperval'
            ValidarDataAte(ordemValidar); //Validade Data
           
            //Else If sAtributo = 'Cdbolsa'
            ValidarCdbolsa(ordemValidar); //Bolsa
           
            //Else If sAtributo = 'TpVctoTermo'
            ValidarTpVctoTermo(ordemValidar); //Vencimento do Termo
           
            //Else If sAtributo = 'NrqtdAnV'
            ValidarNrqtdAnV(ordemValidar); //Anexo V
           
            //Else If sAtributo = 'NrqtdAnIV'
            ValidarNrqtdAnIV(ordemValidar); //Anexo IV
           
            //Else If sAtributo = 'VlDolar'
            ValidarVlDolar(ordemValidar); //Dolar
           
            //Else If sAtributo = 'InDistribui'
            ValidarInDistribui(ordemValidar); //Se eh distribuida
           
            //Else If sAtributo = 'QtCancofe'
            ValidarQtCancofe(ordemValidar); //Quantidade cancelada
           
            //Else If sAtributo = 'InAdminCon'
            ValidarInAdminCon(ordemValidar); //Checkbox Admincon
           
            //Else If sAtributo = 'NrSeqordOri'
            ValidarNrSeqordOri(ordemValidar); //Orig. (Numero Sequencia Ordem Original)(discricionaria)

            if (validationException != null
                && validationException.ValidationErrors != null
                && validationException.ValidationErrors.Count > 0)
            {
                throw validationException;
                //return false;
            }

            //Return TRUE
            return true;

        }

        /// <summary>
        /// Descricao : Executa a inclusao de ordem normal ou mega-bolsa
        /// Autor : Eduardo Sertorio
        /// Data : 27/12/2007
        /// </summary>
        /// <param name="ordemValidar">ordem para incluir</param>
        /// <returns>ordem incluida</returns>
        private BusinessEntity.Ordem ExecutarIncluirOrdem(BusinessEntity.Ordem ordemIncluir)
        {
            //declarar
            ResourceAccess.Ordem raOrdem = new ResourceAccess.Ordem();
            bool bEPop = false;
            int nSeq = 0;

            //verifica permissao para incluir ordem ("mãe", ou "capa" ou "principal")
            if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("IORD")) //incluir - eduardo sertorio - 200804241754 - ref issue ID0003474
            {
                throw new BusinessException(ERRO_ORDEM_SEMPERMISSAOINCLUIRORDEM); //"Usuário sem permissão para incluir ordem."  //incluido - eduardo sertorio - 200804241754 - ref issue ID0003474
            }

            /// Data:23/01/2008 10:39
            /// Autor:DMilanez.7Comm
            /// Obs: Correcao
            /// Metodo adicionado para realizar as validacoes de campos obrigatorios antes de
            /// incluir a ordem
            ValidarObrigatoriosOrdem(ordemIncluir,"I");

            /// Data:21/01/2008 18:18
            /// Autor:DMilanez.7Comm
            /// Obs: 
            /// Alterado de forma a recuperar a data de movimento ao invez de utilizar a data do dia (DateTime.Today)
            DateTime dDatMov = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();
            DateTime dDathora = dDatMov;

            //Set bOrdemExe = FALSE
            bOrdemExe = false;

            //Set bOrdemFin = FALSE
            bOrdemFin = false;

            /// Data:21/01/2008 18:18
            /// Autor:DMilanez.7Comm
            /// Obs: Atribuir a data da ordem com a data do movimento atual
            ordemIncluir.DataOrdem = dDatMov;

            //!
            //! flockpar monta data da tordatmov com hora do sysdate para dt_horord
            //! kleber
            //!
            #region if01
            //If __fValidaAttributeForInsert ( )
            if(ValidarIncluirOrdem(ordemIncluir))
            {
                /// Data:21/01/2008 15:13
                /// Autor:DMilanez.7Comm
                /// Obs: Alterada forma de comparar o mercado           
                bEPop = ordemIncluir.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Estruturado; //TIPO MERCADO IGUAL A ESTRUTURADO - Nemir - 20071227

                //    If ValidarTipoOrdem() and ValidarOpcoes() and ValidarLoteOpcao()
                #region if02
                if (ValidarTipoOrdem(ordemIncluir)
                    && ValidarOpcoes(ordemIncluir)
                    && ValidarLoteOpcao(ordemIncluir))
                {
                    // If fLockPar(dDatmov, nSeq, dDathora)
                    #region if03
                    if (LockPar(dDatMov, ref nSeq, ref dDathora))
                    {
                        // ! Call fChangeDateAttribute('Nrhorord', dDathora)
                        // If TipordF = 'S' or bEPop
                        #region if04
                        if (ordemIncluir.TipoOrdem.Contains(TipoOrdem.Financiamento)
                            || bEPop)
                        {
                            // If bOrdemMae
                            #region if05
                            if (bOrdemMae)
                            {
                                // Call fChangeDateAttribute('Nrhorord', dDathora)
                                ordemIncluir.HoraOrdem = dDathora;
                                // Set nSeq = nSeq + 1
                                nSeq = nSeq + 1;
                                // Call fChangeDateAttribute('Dtdatord', dDatmov)
                                ordemIncluir.DataOrdem = dDatMov;
                                // Call fChangeNumberAttribute('Nrsubseq', 0)
                                ordemIncluir.NumeroOrdemSubSequencia = 0;
                                // Call fChangeNumberAttribute('Nrseqord', nSeq)
                                ordemIncluir.NumeroOrdem = nSeq;
                            }
                            // Else
                            else
                            {
                                // Call fChangeNumberAttribute('Nrsubseq',  fBuscaMaxSubseq ( Nrseqord ) + 1)
                                ordemIncluir.NumeroOrdemSubSequencia = BuscaMaxSubseq(ordemIncluir.NumeroOrdem.Value) + 1;
                            }
                            #endregion if05
                        }
                        // Else
                        else
                        {
                            // Call fChangeDateAttribute('Dtdatord', dDatmov)
                            ordemIncluir.DataOrdem = dDatMov;
                            // Call fChangeDateAttribute('Nrhorord', dDathora)
                            ordemIncluir.HoraOrdem = dDathora;
                            // Set nSeq = nSeq + 1
                            nSeq = nSeq + 1;
                            // Call fChangeNumberAttribute('Nrsubseq', 0)
                            ordemIncluir.NumeroOrdemSubSequencia = 0;
                            // Call fChangeNumberAttribute('Nrseqord', nSeq)
                            ordemIncluir.NumeroOrdem = nSeq;

                        } //corrigida a localizacao deste fechamento de (// If TipordF = 'S' or bEPop ) - esertorio - 200804161651 - ref issue ID0003228
                        #endregion if04

                        // If Incasaord = ''
                        if (!ordemIncluir.IndicadorOrdemFilaCasamento.HasValue)
                        {
                            // Call fChangeStrAttribute('Incasaord', 'S')
                            ordemIncluir.IndicadorOrdemFilaCasamento = true;
                        }

                        // Call fChangeNumberAttribute('Nrqtdfec', 0)
                        ordemIncluir.QuantidadeCasada = 0;
                        // ! Call fChangeStrAttribute('Nmcliente', 'cObjTormovd.fInsert')
                        // Call fChangeStrAttribute('Insituac', 'A')
                        ordemIncluir.Situacao = "A";
                        // Call fChangeStrAttribute('InDesSaldo', 'N')
                        ordemIncluir.IndicadorDesprezaSaldo = false;
                        // Call fChangeStrAttribute('Indistrib', 'N')
                        ordemIncluir.IndicadorDistribuicao = "N";

                        // Set sTudo = sParte1||sParte2
                        //sTudo = sParte1 + sParte2; //nao se aplica - 20080128
                        //            Set nTudo = SalStrToNumber( sTudo )
                        //Int32.TryParse(sTudo, out nTudo); //nao se aplica - 20080128
                        //            Call fChangeNumberAttribute('Nrtipord', nTudo)//sem uso - atributo TipoOrdem ja contem os enums TipoOrdem //eduardo - 20080111
                        //            Set sProcesso = 'I' //sem uso

                        // Call fChangeNumberAttribute('CdUsuario', oAcesso.fGetUsuario() )   - OBTEM USUARIO LOGADO
                        ordemIncluir.CodigoUsuarioConectado = Sinacor.Infra.Service.Security.Authorization.AuthorizationContext.Current.UserId;

                        // If not fExisteBloqueio( )
                        #region if06
                        if (!ExisteBloqueio(ordemIncluir))
                        {
                            // Call fVeriSaldNgcv( fGetSqlHandle(), Cdcliente, Cdnegsp, Cdmercad, Cdnatope, Nrqtdord )
                            VeriSaldNgcv(ordemIncluir);

                            // Call fBeginTransaction()
                            BeginTransaction();

                            #region if07
                            // If cHstBsnObj.fInsert()  INSERT DA ORDEM CO VARIAVEIS GLOBAIS fChangeStrAttribute
                            int retornoIncluirOrdem = (new ResourceAccess.Ordem()).IncluirOrdem(ordemIncluir); //alterado - esertorio - 200804161648 - ref issue ID0003209
                            if (retornoIncluirOrdem == 1)
                            {
                                // ! Call fEnableMsg(MSG_INFORMATION, TRUE)
                                #region if08
                                // If bOrdemMae OR Nrsubseq = 0
                                if (bOrdemMae || ordemIncluir.NumeroOrdemSubSequencia == 0)
                                {
                                    // ! Se primeiro registro de financiamento, atualiza número sequencial
                                    #region if09
                                    // If fUpdatePar(nSeq)  ATUALIZA NUMERO DA ORDEM
                                    if (UpdatePar(nSeq))
                                    {
                                        //                            Call fAlteraAnt() //sem uso
                                        AlteraAnt(ordemIncluir);
                                        //                            Call fEndTransaction()
                                        EndTransaction();
                                        //                            ! Call fVeriSaldNgcv( fGetSqlHandle(), Cdcliente, Cdnegsp, Cdmercad, Cdnatope, Nrqtdord )
                                        //                            Set bOrdemMae = FALSE
                                        bOrdemMae = false;
                                        //                            Return TRUE
                                    }
                                    // Else
                                    else
                                    {
                                        //                            Call fCancelTransaction()
                                        CancelTransaction();
                                        //                            Return FALSE
                                    }
                                    #endregion if09
                                }
                                // Else
                                else
                                {
                                    // Call fAlteraAnt()
                                    AlteraAnt(ordemIncluir);
                                    //                        Call fEndTransaction()
                                    EndTransaction();
                                    //                        Call fVeriSaldNgcv( fGetSqlHandle(), Cdcliente, Cdnegsp, Cdmercad, Cdnatope, Nrqtdord )
                                    VeriSaldNgcv(ordemIncluir);
                                    //                        Return TRUE
                                }
                                #endregion if08
                            }
                            //                Else
                            else
                            {
                                //                    Call fCancelTransaction()
                                CancelTransaction();
                                //                    Return FALSE
                            } //if cHstBsnObj.fInsert else ...
                            #endregion if07

                        } //if ExisteBloqueio() ...
                        #endregion if06
                        //            Else
                        //                Return FALSE

                    } //if LockPar ...
                    //    Else
                    //        Return FALSE
                    #endregion if03

                } //if ValidarTipoOrdem...
                //Else
                else //incluido - esertorio - 200804112150 - ref issue ID0002954
                {
                    //    Return FALSE
                    if (validationException != null
                        && validationException.ValidationErrors != null
                        && validationException.ValidationErrors.Count > 0)
                        throw validationException;  //incluido - esertorio - 200804112150 - ref issue ID0002954
                }
                #endregion if02

            } //if ... ja foi validado ...
            #endregion if01

            //retornar
            return ordemIncluir;
        }

        /// <summary>
        /// Data:23/01/2008 10:40
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Metodo responsavel por verificar os campo minimos obrigatorios para incluir/alterar/excluir uma ordem
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <param name="acao">I - Inclusao , A - Atualizacao, E - Exclusao</param>
        private void ValidarObrigatoriosOrdem(BusinessEntity.Ordem ordemValidar,string acao)
        {
            ValidationException ex = new ValidationException();

            if (ordemValidar == null)
            {
                ex.AddError(ERRO_ORDEM_OBJETOORDEMNULO);
                throw ex;
            }

            ///se atualizacao ou exclusao validar a chave
            if (acao == "A" || acao == "E")
            {
                if (!ordemValidar.DataOrdem.HasValue)
                    ex.AddError(ERRO_ORDEM_DATAORDEMNAOINFORMADA);

                if (!ordemValidar.NumeroOrdem.HasValue)
                    ex.AddError(ERRO_ORDEM_NUMERONAOINFORMADO);

                if (!ordemValidar.NumeroOrdemSubSequencia.HasValue)
                    ex.AddError(ERRO_ORDEM_NUMEROSEQUENCIANAOINFORMADO);

                //incluido - eduardo sertorio - 200802271245
                if (String.IsNullOrEmpty(ordemValidar.TextoJustificativa))
                    ex.AddError(ERRO_JUSTIFICATIVADEVESERINFORMADA);
            }

            ///se n for exclusao, validar os demais campos
            if (acao != "E")
            {
                ///validar se otipo de ordem nao foi informado
                if (ordemValidar.TipoOrdem == null || ordemValidar.TipoOrdem.Count == 0)
                    ex.AddError(ERRO_ORDEM_TIPOORDEMNULO);
                else
                    //se foi informado e tipo da ordem NÃO É Financiamento
                    if (!ordemValidar.TipoOrdem.Contains(TipoOrdem.Financiamento)) //incluido - esertorio - 200804161508 - ref issue ID0003223
                        ///validar se a natureza foi informada
                        if (!ordemValidar.NaturezaOperacao.HasValue)
                            ex.AddError(ERRO_ORDEM_NATUREZAOPERACAONULO);

                ///validar se o mercado foi informado
                if (!ordemValidar.TipoMercado.HasValue)
                    ex.AddError(ERRO_ORDEM_MERCADONULO);

                ///validar se o titulo foi informado
                ///titulo nao pode ser informado para criar ordem tipo Financiamento - eduardo sertorio - 200802271748
                ///esta validacao sera feita mais adiante
                //if (String.IsNullOrEmpty(ordemValidar.Titulo)) //comentado - eduardo sertorio - 200802271750
                //    ex.AddError(ERRO_ORDEM_TITULONULO); //comentado - eduardo sertorio - 200802271750

                if (!ordemValidar.NumeroOrdemOriginal.HasValue)
                    ex.AddError(ERRO_ORDEM_NUMEROORDEMORIGINALNAOINFORMADO);

            }

            if (ex != null && ex.ValidationErrors != null && ex.ValidationErrors.Count > 0)
                throw ex;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 18/01/2008
        /// </summary>
        /// <param name="dDatmov"></param>
        /// <param name="nSeq"></param>
        /// <param name="dDathora"></param>
        /// <returns></returns>
        private bool LockPar(DateTime dtDatMov, ref int nSeq,ref DateTime dDathora) 
        { 
            DateTime dAux = (new Parametro.BusinessLogic.Parametro()).RecuperarDataSistemaBancoDados();
            dDathora = new DateTime(dtDatMov.Year, dtDatMov.Month, dtDatMov.Day, dAux.Hour, dAux.Minute, dAux.Second);            
            
            nSeq = 0;
            nSeq = new ResourceAccess.Ordem().GerarNumero(null);

            return !(nSeq==0);
        }

        /// <summary>
        /// Alterar numero de sequencia da ordem
        /// Autor: Eduardo Sertorio
        /// Data: 11/01/2008
        /// </summary>
        /// <param name="numeroSequenciaOrdem"></param>
        /// <returns></returns>
        private bool UpdatePar(int numeroSequenciaOrdem) 
        {
            //If SqlPrepareAndExecute( hSqlGeral,
            //        "UPDATE TORSEQORD SET NR_SEQORD = :nSeq")                                
            //    Return TRUE
            //Else
            //    Return FALSE
            int linhasAfetadas = (new ResourceAccess.Ordem()).AlterarNumero(numeroSequenciaOrdem);

            if (linhasAfetadas ==1 )
                return true;
            else
                return false;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 09/01/2008
        /// </summary>
        /// <param name="ordemVerificar"></param>
        /// <returns></returns>
        private bool fEPop(BusinessEntity.Ordem ordemVerificar)
        {
            //Function: fEPop
            //Description:
            //Returns
            //    Boolean:
            //Parameters
            //Static Variables
            //Local variables
            //    Number: nStatus
            //    Number: nQtd
            //Actions
            //    Call SqlPrepareAndExecute( hSqlGeral, "
            //            SELECT 0
            //              FROM TORMOVD 
            //             WHERE dt_datord = :Dtdatord
            //               and NR_SEQORD = :Nrseqord
            //               AND IN_SITUAC = 'A'
            //               AND NR_SUBSEQ = 0
            //               and substr( cd_codcas, 7, 2 ) = 'PP'
            //              INTO :nQtd") 
            //    Call SqlFetchNext( hSqlGeral, nStatus )
            //    !
            //    If nStatus = FETCH_EOF
            //        Return FALSE
            //    !
            //    Return TRUE

            return (new Ordens.ResourceAccess.Ordem()).VerificaCodigoCasamentoPP(ordemVerificar);
        }

        /// <summary>
        /// Obtem ULTIMO Numero de SUB Sequencia da Ordem
        /// Data: 11/01/2008
        /// Autor: Eduardo Sertorio
        /// </summary>
        /// <param name="numeroSequenciaOrdem"></param>
        /// <returns></returns>
        private int BuscaMaxSubseq(int numeroSequenciaOrdem)
        {
            BusinessEntity.Ordem beOrdem = new BusinessEntity.Ordem();
            beOrdem.NumeroOrdem = numeroSequenciaOrdem;
            beOrdem.DataOrdem = DateTime.MinValue; //atribuir [DateTime.MinValue] para anular o parametro no filtro da consulta.
            return (new ResourceAccess.Ordem()).ConsultarNumeroSubSequencia(beOrdem);
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 09/01/2008
        /// Nao implementado - Nao se aplica a esta arquitetua
        /// </summary>
        private void BeginTransaction() 
        {
            //nao implementado - eduardo - 20080109
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 09/01/2008
        /// Nao implementado - Nao se aplica a esta arquitetua
        /// </summary>
        private void EndTransaction() 
        {
            //nao implementado - eduardo - 20080109
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 09/01/2008
        /// Nao implementado - Nao se aplica a esta arquitetua
        /// </summary>
        private void CancelTransaction()
        {
            //nao implementado - eduardo - 20080109
        }

        /// <summary>
        /// Campo "Quantidade"
        /// Autor: Eduardo Sertorio
        /// Data: 27/12/2007
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns>bool</returns>
        private bool ValidarNrqtdord(BusinessEntity.Ordem ordemValidar)
        { 
            if (bOrdemMae)
            {
                //If TipordF = 'S' -- TipordF -> Tipo da Ordem = 'Financiamento'
                if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)) // TipordF -> Tipo da Ordem = 'Financiamento'
                {
                    //If Nrqtdord = NUMBER_Null or Nrqtdord = 0
                    if (!ordemValidar.Quantidade.HasValue || ordemValidar.Quantidade == 0)
                    {
                        ordemValidar.Quantidade = 0;
                        return true;
                    }
                    else
                    {                        
                        if ( 
                             validationException.ValidationErrors == null ||
                             validationException.ValidationErrors.Count == 0
                           )
                        {
                            validationException.AddError(ERRO_ORDEM_QUANTIDADENAONULOPARAFINANCIAMENTO); //"Quantidade da ordem deve ser nula para financiamento."
                        }
                        return false;
                    }
                }
                else
                {
                    if (!ordemValidar.Quantidade.HasValue || ordemValidar.Quantidade == 0)
                    {
                        validationException.AddError(ERRO_ORDEM_QUANTIDADEINVALIDA); //"Quantidade da ordem inválida."
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
            }
            else
            {
                if (!ordemValidar.Quantidade.HasValue || ordemValidar.Quantidade == 0)
                {
                    validationException.AddError(ERRO_ORDEM_QUANTIDADEINVALIDA); //"Quantidade da ordem inválida."
                    return false;
                }
                else
                {
                    return true;
                }
            }

        }
        
        /// <summary>
        /// Campo "Titulo"
        /// Autor: Eduardo Sertorio
        /// Data: 27/12/2007
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarCdnegsp(BusinessEntity.Ordem ordemValidar)
        { 
            
            bool bOrdemMaeF = true;
            int nParNum = 0;
            string sData = "";

            #region if0001
            if (bOrdemMae && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento))
            {
                bOrdemMaeF = true;
            }
            else
            {
                bOrdemMaeF = false;
            }
            #endregion if0001

            #region if0002
            if (bOrdemMaeF)
            {
                if (String.IsNullOrEmpty(ordemValidar.Titulo)) // Título
                    return true;
                else
                {
                    validationException.AddError(ERRO_ORDEM_TITULONAONULOPARAFINANCIAMENTO); //"Código do papel deve ser nulo para financiamento"
                    return false;
                }
            }
            #endregion if0002

            //"Código do papel não pode ser nulo."
            #region if0003
            if (String.IsNullOrEmpty(ordemValidar.Titulo))
            {
                validationException.AddError(ERRO_ORDEM_TITULONULO); //"Código do papel não pode ser nulo."
                return false;
            }
            #endregion if0003

            // Admincon (Administrado Concorrente)
            #region if0004
            if (!ordemValidar.IndicadorOrdemAbertaAdminCon.HasValue)
            {
                if (pOrdemNaoAlterada != null && pOrdemNaoAlterada.IndicadorOrdemAbertaAdminCon.HasValue) //alterado - eduardo sertorio - 200802261301
                {
                    ordemValidar.IndicadorOrdemAbertaAdminCon = pOrdemNaoAlterada.IndicadorOrdemAbertaAdminCon;
                }
                else
                {
                    validationException.AddError(ERRO_ORDEM_INDICADORORDEMADMINCONNAOINFORMADO); //incluido - eduardo sertorio - 200802261301
                    return false;
                }
            }

            if (ordemValidar.IndicadorOrdemAbertaAdminCon.Value) // Admincon (Administrado Concorrente)
            {
                /// Data:22/01/2008 12:10
                /// Autor:DMilanez.7Comm
                /// Obs: Correcao
                /// verificar se a pOrdemNaoAlterada foi recuperada
                if (pOrdemNaoAlterada != null && ordemValidar.Titulo != pOrdemNaoAlterada.Titulo
                    && String.IsNullOrEmpty(ordemValidar.Titulo))
                {
                    validationException.AddError(ERRO_ORDEM_TITULOALTERADO); //"Código do papel, para ordem do tipo Administrada Concorrente, não pode ter o papel alterado"
                    return false;
                }
            }
            #endregion if0004

            #region if0005
            if (!ordemValidar.TipoMercado.HasValue) // Mercado
            {
                validationException.AddError(ERRO_ORDEM_MERCADONULO); //"Mercado não informado." ("Escolha primeiro o mercado !.")
                return false;
            }
            #endregion if0005

            #region titulo
            Titulo.BusinessEntity.Titulo beTituloRequest = new Titulo.BusinessEntity.Titulo();

            beTituloRequest.TipoMercado = (Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado) ordemValidar.TipoMercado.Value;
            beTituloRequest.Codigo = ordemValidar.Titulo;
            beTituloRequest.DataOrdem = ordemValidar.DataOrdem.Value;

            pTituloIncluir = (new Titulo.ResourceAccess.Titulo()).ConsultarCodigoIsinDataVencimento(beTituloRequest);

            /// Data:23/01/2008 10:34
            /// Autor:DMilanez.7Comm
            /// Obs: Correcao
            /// Caso n encontre o titulo devera parar a execucao
            if (pTituloIncluir == null)
                throw new BusinessException(ERRO_ORDEM_TITULOINVALIDOPARAMERCADO);

            //Call fChangeStrAttribute('Cdcodisi', sCdcodisi) --atribuir para classe(Business Entity) do titulo
            ordemValidar.CodigoISIN = pTituloIncluir.CodigoISIN;
            #endregion titulo

            //Call fWhereMerMega(Cdmercad, sParteWhere) -- sParteWhere := "A.CD_TPMERC =" || Cdmercad
            //Call SqlPrepareAndExecute( fGetSqlHandle(), "select   B.NR_FATCOT, A.CD_TPMERC, A.CD_CODISI, to_char(A.DT_DATVEN,'DDMMYYYY')                  
            //                     FROM TBOTITULOS A, TBOTITFAT B  
            //                     WHERE " || sParteWhere || " and
            //                                         A.CD_CODNEG  =  :Cdnegsp
            //                      AND            A.DT_ININEG   <=  :Dtdatord
            //                      AND            A.DT_LIMNEG  >=  :Dtdatord 
            //                      AND            A.CD_CODNEG   =  B.CD_CODNEG
            //                      AND            A.DT_ININEG      =  B.DT_ININEG
            //                      AND            A.CD_TPMERC   =  B.CD_TPMERC
            //                      AND            B.DT_INIFAT     <=  :Dtdatord
            //                      AND            B.DT_FIMFAT    >= :Dtdatord
            //                                 INTO :nNrFatcot, :sGMerc, :sCdcodisi, :sData" )

		    //Call SqlFetchNext( fGetSqlHandle(),nStatus )
            //If nStatus = 0 
            #region if01
            if (pTituloIncluir!=null)
            {
                #region if02
                //If Cdmercad = 'OPC'
                if( ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra 
                    //OR Cdmercad = 'OPV'  
                    || ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda
                    //OR Cdmercad = 'FUT' 
                    || ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Futuro
                    //OR Cdmercad = 'VFU') 
                    || ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.VencimentoFuturo )
                    // Cdmercad = Mercado
                {        
                    //Call fChangeStrAttribute('Cdcodcas', sCdcodisi || Cdnegsp ) --concatenar(||) e atribuir para BE ordem.Cdcodcas
                    ordemValidar.CodigoCasamento = ordemValidar.CodigoISIN + ordemValidar.Titulo;

                    //Return TRUE
                    return true;
                }
                else
                {
                    //If Cdmercad = 'TER'
                    #region if03
                    if( ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo)
                    {
                        //Set nParNum = SalStrToNumber (SalStrMidX( Cdnegsp, 4, 2 )) --pega 02 caract a partir da 5a pos inclusive
                        //nParNum = Int32.Parse(ordemValidar.Titulo.Substring(4,2));
                        Regex r = new Regex(@"\d");
                        nParNum = Int32.Parse(r.Match(ordemValidar.Titulo).Value);

                        //If nParNum > 50
                        #region if04
                        if ( nParNum > 50)
                        {
                            //if( TpVctoTermo != NUMBER_Null) //Vencimento do Termo
                            #region if05
                            if(ordemValidar.VencimentoTermo.HasValue)
                            {
                                //Call fDisplayError( 'Termo em Pontos não tem Prazo.' )
                                validationException.AddError(ERRO_ORDEM_VENCIMENTOTERMOINVALIDO); //"Termo em Pontos não tem Prazo."
                                //Return FALSE
                                return false;
                            }
                            else
                            {
                                //Call fChangeStrAttribute('Cdcodcas', sCdcodisi || sData )
                                sData = Sinacor.Servico.Bovespa.BovespaBase.Util.Funcoes.FormatarData(beTituloRequest.DataVencimentoTermo.Value,"/");
                                ordemValidar.CodigoCasamento = ordemValidar.CodigoISIN + sData;
                                //Return TRUE
                                return true;
                            }
                            #endregion if05
                        }
                        else
                        {
                            //if( TpVctoTermo = NUMBER_Null)
                            #region if06
                            if(!ordemValidar.VencimentoTermo.HasValue)
                            {
                                //Call fDisplayError( 'Termo deve ter Prazo.' )
                                validationException.AddError(ERRO_ORDEM_VENCIMENTOTERMONULO); //"Termo deve ter Prazo."
                                //Return FALSE
                                return false;
                            }
                            else
                            {
                                //Call fChangeStrAttribute('Cdcodcas', sCdcodisi || SalNumberToStrX( TpVctoTermo, 0) )
                                string sTpVctoTermo;

                                if(ordemValidar.VencimentoTermo.HasValue)
                                    sTpVctoTermo = ordemValidar.VencimentoTermo.Value.ToString();
                                else
                                    sTpVctoTermo = "0";

                                ordemValidar.CodigoCasamento = ordemValidar.CodigoISIN + sTpVctoTermo;
                                //Return TRUE
                                return true;
                            }
                            #endregion if06
                        }
                        #endregion if04
                    }
                    else
                    {
                        //Call fChangeStrAttribute('Cdcodcas', sCdcodisi)
                        ordemValidar.CodigoCasamento = ordemValidar.CodigoISIN;
                        //Return TRUE
                        return true;
                    }
                    #endregion if03
                }
                #endregion if02
            }
            else
            {
                //Call fDisplayError( 'Papel não cadastrado para o mercado !.' )
                validationException.AddError(ERRO_ORDEM_TITULOINVALIDOPARAMERCADO); //"Papel não cadastrado para o mercado !."
                //Return FALSE
                return false;
            }
            #endregion if01

        }

        /// <summary>
        /// Campo nao visivel "Codigo do Cliente"
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarCdcliente(BusinessEntity.Ordem ordemValidar)
        { 
            //If Cdcliente = NUMBER_Null -- Cdcliente obtido na consulta do apelido do cliente
            if (!ordemValidar.CodigoCliente.HasValue)
            {
                //    Call fDisplayError( 'Código do cliente inválido.' )
                validationException.AddError(ERRO_ORDEM_CODIGOCLIENTENAOINFORMADO); //"Código do cliente não informado."
                //    Return FALSE
                return false;
            }

            //If Cdcliente != 0
            if (ordemValidar.CodigoCliente.Value != 0)
            {
                //    Set Nmcliente = ''
                ordemValidar.NomeCliente = "";
            }

            pClienteIncluir = new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente().ConsultarPorCodigo(ordemValidar.CodigoCliente.Value);

            if (pClienteIncluir == null)
            {
                validationException.AddError(ERRO_ORDEM_CODIGOCLIENTEINVALIDO); //"Código do cliente inválido."
                return false;
            }
            else
            {
                if (pClienteIncluir.Situacao.HasValue && pClienteIncluir.Situacao.Value ==  Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoSituacao.Ativo) //incluido - esertorio - 200805021527 - ref issue ID0003694
                {
                    /// Data:22/01/2008 12:02
                    /// Autor:DMilanez.7Comm
                    /// Obs: Correcao
                    /// Atribuir valores recebidos do cliente para a ordem
                    ordemValidar.CodigoCliente = pClienteIncluir.Codigo;
                    ordemValidar.ApelidoCliente = pClienteIncluir.Apelido;
                    ordemValidar.DigitoCliente = pClienteIncluir.Digito;
                    ordemValidar.NomeCliente = pClienteIncluir.Nome;
                }
                else
                {
                    throw new BusinessException(ERRO_ORDEM_CLIENTEDESATIVADO); //incluido - esertorio - 200805021527 - ref issue ID0003694
                    //return false;
                }
            }

            //    ! njo
            //If Inqualificado = 'S' -- Inqualificado obtido na consulta do apelido do cliente            
            if (pClienteIncluir.isClienteQualificado)
            {
                //    If Cdbolsa != '1' and Cdbolsa != '5' and Cdbolsa != '8' -- Bolsa
                if ( ordemValidar.Bolsa != "1"
                    && ordemValidar.Bolsa != "5"
                    && ordemValidar.Bolsa != "8")
                {
                    //        Call fDisplayError( 'Cliente Qualificado somente para BOVESPA, SOMA e MAIS' )
                    validationException.AddError(ERRO_ORDEM_CLIENTEINVALIDOPARABOLSAINFORMADA); //"Cliente Qualificado somente para BOVESPA, SOMA e MAIS."
                    //        Return FALSE
                    return false;
                }
            }

            //If InAdminCon = 'S' -- checkbox Admincon
            if (ordemValidar.IndicadorOrdemAbertaAdminCon.Value)
            //    If Cdcliente != CdclienteA and CdclienteA != 0 and CdclienteA != NUMBER_Null
                if (pOrdemNaoAlterada != null 
                    && pOrdemNaoAlterada.CodigoCliente.HasValue
                    && pOrdemNaoAlterada.CodigoCliente != 0
                    && ordemValidar.CodigoCliente != pOrdemNaoAlterada.CodigoCliente
                    )
                {
                    //        Call fDisplayError( 'Ordem do tipo Administrada Concorrente não pode ter o código de cliente alterado' )
                    validationException.AddError(ERRO_ORDEM_CLIENTEALTERADOORDEMADMINCON); //"Ordem do tipo Administrada Concorrente não pode ter o código de cliente alterado."
                    //        Return FALSE
                    return false;
                }
            /// Data:23/01/2008 16:42
            /// Autor:DMilanez.7Comm
            /// Obs: Correcao
            /// Removido por estar redundante
            //Return ValidarDvcliente()
            ///return ValidarDvcliente(ordemValidar);
            return true;
        }

        /// <summary>
        /// Campo "Digito Verificador do Cliente" (ao lado do campo Apelido)
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarDvcliente(BusinessEntity.Ordem ordemValidar)
        { 
            //If Dvcliente = NUMBER_Null
            if (!ordemValidar.DigitoCliente.HasValue)
            {
                //    Call fDisplayError( 'Dígito do cliente inválido.' )
                validationException.AddError(ERRO_ORDEM_DIGITOCODIGOCLIENTENULO); //"Dígito do cliente está nulo."
                //    Return FALSE
                return false;
            }
            else
                return true;

            /// Data:22/01/2008 12:24
            /// Autor:DMilanez.7Comm
            /// Obs: Correcao
            /// Removido por ja estar sendo validado 
            /// 
            ////Call SqlPrepareAndExecute( fGetSqlHandle(), "
            ////        Select 0 from tscclibol
            ////         where cd_cliente = :Cdcliente
            ////           and dv_cliente = :Dvcliente" )
            ////Call SqlFetchNext( fGetSqlHandle(), nRet )
            //pClienteIncluir = new Cliente.ResourceAccess.Cliente().ConsultarPorCodigoDigito(ordemValidar.CodigoCliente.Value,ordemValidar.DigitoCliente.Value);

            ////If nRet = FETCH_EOF and Cdcliente != 0
            //if (pClienteIncluir == null)
            //{
            //    //    Call fDisplayError( 'Dígito do cliente incorreto.' )
            //    validationException.AddError(ERRO_ORDEM_DIGITOCODIGOCLIENTEINVALIDO); //"Dígito do cliente incorreto."
            //    //    Return FALSE
            //    return false;
            //}
            //else
            //{
            //    //Return TRUE
            //    return true;
            //}
        }

        /// <summary>
        /// Campo "Operador"
        /// (codido do usuario conectado (GetUserID) ou combo "Operador" quando usuario é tipo ADM (ponta de mesa))
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarCdOperador(BusinessEntity.Ordem ordemValidar) 
        { 
            //-- TORMOVD.CD_CODUSU - usuario conectado nao ADM 
            //-- ou usuario da combo Operador se usuario conectado for ADM
            //-- ADM = ponta de mesa = abre ordens para outros operadores)
            //If Cdcodusu = NUMBER_Null or Cdcodusu = 0  
            if (!ordemValidar.CodigoUsuarioOrdem.HasValue 
                || ordemValidar.CodigoUsuarioOrdem.Value == 0)
            {
                //    Call fDisplayError( 'Código do Operador inválido.' )
                validationException.AddError(ERRO_ORDEM_CODIGOOPERADORINVALIDO); //"Código do Operador inválido."
                //    Return FALSE
                return false;
            }

            //Return TRUE
            return true;
        }

        /// <summary>
        /// Campo "Natureza"
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns>bool</returns>
        private bool ValidarCdnatope(BusinessEntity.Ordem ordemValidar)
        {
            //If TipordF != 'S' 
            if (!ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento))
            {
                //    If Cdnatope  = '' -- Natureza
                if (!ordemValidar.NaturezaOperacao.HasValue)
                {
                    //        Call fDisplayError( 'Natureza da operação não pode ser nula.' )
                    validationException.AddError(ERRO_ORDEM_NATUREZAOPERACAONULO); //"Natureza da operação não pode ser nula."
                    //        Return FALSE
                    return false;
                }
            }

            //!
            //If InAdminCon = 'S'
            if (ordemValidar.IndicadorOrdemAbertaAdminCon.Value)
            {                
                //    If Cdnatope != CdnatopeA and CdnatopeA != ''
                if (pOrdemNaoAlterada != null &&
                    pOrdemNaoAlterada.NaturezaOperacao.HasValue
                    && ordemValidar.NaturezaOperacao.Value != pOrdemNaoAlterada.NaturezaOperacao.Value)
                {
                    //        Call fDisplayError( 'Ordem do tipo Administrada Concorrente não pode ter a natureza de operação alterada' )
                    validationException.AddError(ERRO_ORDEM_NATUREZAOPERACAOALTERADAORDEMADMINCON); //"Ordem do tipo Administrada Concorrente não pode ter a natureza de operação alterada."
                    //        Return FALSE
                    return false;
                }
            }
            //!
            //Return TRUE
            return true;
        }

        /// <summary>
        /// Campo "Mercado"
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns>bool</returns>
        private bool ValidarCdmercad(BusinessEntity.Ordem ordemValidar)
        {
            //If Cdmercad = '' --Mercado
            if (!ordemValidar.TipoMercado.HasValue)
            {
                //    Call fDisplayError( 'Mercado não pode ser nulo.' )
                validationException.AddError(ERRO_ORDEM_MERCADONULO); //"Mercado não pode ser nulo."
                //    Return FALSE
                return false;
            }

            //If TipordF = 'S' 
            if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento))
            {
                //    If bOrdemMae
                if (bOrdemMae)
                {
                    //        If Cdmercad != 'TER'
                    if (ordemValidar.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo)
                    {
                        //            Call fDisplayError( 'Mercado deve ser Termo para financiamento.' )
                        validationException.AddError(ERRO_ORDEM_MERCADOINVALIDOPARAFINANCIAMENTO); //"Mercado deve ser Termo para financiamento.
                        //            Return FALSE
                        return false;
                    }
                    //        Else
                    else
                    {
                        //            Return TRUE
                        return true;
                    }
                }
                //    Else
                else
                {
                    //        Return TRUE
                    return true;
                }
            }

            /// Data:23/01/2008 16:32
            /// Autor:DMilanez.7Comm
            /// Obs: Correcao
            /// Removido por estar reduntante
            //Return ValidarInliquida()
            ///return ValidarInliquida(ordemValidar);
            return true;
        }

        /// <summary>
        /// Campo "TP.Liq" (Tipo de Liquidação)
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns>bool</returns>
        private bool ValidarInliquida(BusinessEntity.Ordem ordemValidar)
        { 
            //!
            //! Se é POP
            //If SalStrMidX( Cdcodisi, 6, 2 ) = 'PP'
            //if (ordemValidar.CodigoISIN.Substring(6, 2) == "PP")
            if (VerificarOrdemPOP(ordemValidar))
            {
                //    Call fChangeStrAttribute('Inliquida', '')
                ordemValidar.TipoLiquidacao = EnumToString(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Normal);
            }


            //!
            //If Inliquida = '' OR Inliquida = 'C' OR Inliquida = 'A' -- TP.Liq (tela) 
            if (
                //ordemValidar.TipoLiquidacao == Sinacor.Servico.Bovespa.BovespaBase.Service.Util.TipoLiquidacao.EnumToString(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Normal)
                string.IsNullOrEmpty(ordemValidar.TipoLiquidacao) // correcao - 20080305 - dmilanez - Normal = "" ou null
                || 
                ordemValidar.TipoLiquidacao == EnumToString(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Custodiante)
            //TipoLiquidacao ARBITRAGEM nao existe mais - Kleber - 20080104
                //|| ordemValidar.TipoLiquidacao.Equals(Comum.Util.TipoLiquidacao.EnumToString(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Arbitragem))
                )
            {
                /// Data:22/01/2008 12:37
                /// Autor:DMilanez.7Comm
                /// Obs: Correcao
                /// Trocado Equal por == 
                //    If Inliquida = 'C' OR Inliquida = 'A'
                if (
                    ordemValidar.TipoLiquidacao == EnumToString(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Custodiante)
                    //|| 
                    //ordemValidar.TipoLiquidacao == Sinacor.Servico.Bovespa.BovespaBase.Service.Util.TipoLiquidacao.EnumToString(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Arbitragem)
                    )
                {
                    //        If Cdmercad = 'VIS' 
                    if (ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista
                        // or Cdmercad = 'FRA' -- Mercado (tela)
                        || ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Fracionario
                        // or Cdmercad = 'EOC' 
                        || ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.ExercicioOpcaoCompra
                        // or Cdmercad = 'EOV' or
                        || ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Estruturado
                        // or Cdmercad = 'LEI' 
                        || ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Leilao
                        // or Cdmercad = 'LNC'
                        || ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.LeilaoNaoCotados
                        // or Cdmercad = 'EST'
                        || ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Estruturado
                        )
                    {
                        //            Return TRUE
                        return true;
                    }
                    //        Else
                    else
                    {
                        //            Call fChangeStrAttribute('Inliquida', '')
                        ordemValidar.TipoLiquidacao = EnumToString(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoLiquidacao.Normal);
                        //            Return TRUE
                        return true;
                    }
                }
                //    Else
                else
                {
                    //        Return TRUE
                    return true;
                }
            }
            //Else
            else
            {
            //    Call fDisplayError( ' Tipo de Liquidação Digitado é Invalido !' )
                validationException.AddError(ERRO_ORDEM_TIPOLIQUIDACAOINVALIDO); //"Tipo de Liquidação Digitado é Invalido !"
            //    Return FALSE
                return false;
            }
        }

        /// <summary>
        /// Campo "Nome" (Nome do Cliente)
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarNmcliente(BusinessEntity.Ordem ordemValidar)
        {
            //If Cdcliente = 0
            if (!ordemValidar.CodigoCliente.HasValue || ordemValidar.CodigoCliente == 0)
            {
                //    If Nmcliente  = ''
                if (String.IsNullOrEmpty(ordemValidar.NomeCliente))
                {
                    //        Call fDisplayError( 'Nome do cliente não pode ser nulo.' )
                    validationException.AddError(ERRO_ORDEM_NOMECLIENTENULO); //"Nome do cliente não pode ser nulo."
                    //        Return FALSE
                    return false;
                }
            }

            //Return TRUE
            return true;
        }

        /// <summary>
        /// Campo "%Acrescimo/Redução" (Percentual Reducao Acrescimo)
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns>bool</returns>
        private bool ValidarPcredacr(BusinessEntity.Ordem ordemValidar)
        {
            //If Pcredacr = NUMBER_Null
            if (!ordemValidar.PercentualReducaoAcrescimo.HasValue)
            {
                //    Set Pcredacr = 0
                ordemValidar.PercentualReducaoAcrescimo = 0;
            }

            //Return TRUE
            return true;
        }

        /// <summary>
        /// Campo "Preço"
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar">BusinessEntity.Ordem</param>
        /// <returns>bool</returns>
        private bool ValidarVlprepap(BusinessEntity.Ordem ordemValidar)
        {
            //If Vlprepap = NUMBER_Null
            #region if00
            if (!ordemValidar.Preco.HasValue)
            {
                //    Call fChangeNumberAttribute('Vlprepap', 0)
                ordemValidar.Preco = 0;
            }
            #endregion if00

            //If bOrdemMae
            #region if01
            if (bOrdemMae)
            {
                //    If TipordF = 'S'
                #region if02
                if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento))
                {
                    //        If Vlprepap = NUMBER_Null OR Vlprepap = 0
                    #region if03
                    if (!ordemValidar.Preco.HasValue
                        || ordemValidar.Preco == 0)
                    {
                        //            Return TRUE
                        return true;
                    }
                    //        Else
                    else
                    {
                        //            Call fDisplayError( 'Preço do papel deve ser nulo.' )
                        validationException.AddError(ERRO_ORDEM_PRECOTITULOINVALIDO_01); //"Preço do papel deve ser nulo."
                        //            Return FALSE
                        return false;
                    }
                    #endregion if03
                }
                //    Else
                else
                {
                    //                   ORDEM DO TIPO LIMITADA OU ON STOP
                    //        If TipordL = 'S'  or TipordO = 'S'
                    #region if04
                    if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada)
                        || ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.OnStop))
                    {
                        //            If (Vlprepap = NUMBER_Null OR Vlprepap = 0) 
                        #region if05
                        if (!ordemValidar.Preco.HasValue
                            || ordemValidar.Preco == 0)
                        {
                            //                Call fDisplayError( 'Preço do papel não pode ser nulo.' )
                            validationException.AddError(ERRO_ORDEM_PRECOTITULONULO_01); //"Preço do papel não pode ser nulo."
                            //                Return FALSE
                            return false;
                        }
                        //            Else
                        else
                        {
                            //                Return TRUE
                            return true;
                        }
                        #endregion if05
                    }
                    //        Else
                    else
                    {
                        //            If (Vlprepap = NUMBER_Null OR Vlprepap = 0)
                        #region if06
                        if (!ordemValidar.Preco.HasValue || ordemValidar.Preco == 0)
                        {
                            //                Return TRUE
                            return true;
                        }
                        //            Else
                        else
                        {
                            //                Call fDisplayError( 'Preço do papel deve ser nulo.' )
                            validationException.AddError(ERRO_ORDEM_PRECOTITULOINVALIDO_02); //"Preço do papel deve ser nulo."
                            //                Return FALSE
                            return false;
                        }
                        #endregion if06
                    }
                    #endregion if04
                }
                #endregion if02
            }
            //Else
            else
            {
                //    If (Vlprepap = NUMBER_Null OR Vlprepap = 0) and ( TipordL = 'S'  or TipordO = 'S' )
                #region if07
                if (
                    (
                    !ordemValidar.Preco.HasValue
                    ||
                    ordemValidar.Preco ==0
                    )
                    &&
                    (
                    ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada)
                    ||
                    ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.OnStop)
                    )
                    )
                {
                    //        Call fDisplayError( 'Preço do papel não pode ser nulo.' )
                    validationException.AddError(ERRO_ORDEM_PRECOTITULONULO_02); //"Preço do papel não pode ser nulo."
                    //        Return FALSE
                    return false;
                }
                //    Else
                else
                {
                    //        If TipordF = 'S'
                    #region if08
                    if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento))
                    {
                        //            If Vlprepap = NUMBER_Null OR Vlprepap = 0
                        #region if09
                        if (!ordemValidar.Preco.HasValue || ordemValidar.Preco == 0)
                        {
                            //                Call fDisplayError( 'Preço do papel não pode ser nulo.' )
                            validationException.AddError(ERRO_ORDEM_PRECOTITULONULO_03); //"Preço do papel não pode ser nulo."
                            //                Return FALSE
                            return false;
                        }
                        //            Else
                        else
                        {
                            //                Return TRUE
                            return true;
                        }
                        #endregion if09
                    }
                    //        Else
                    else
                    {
                        //            If Vlprepap = NUMBER_Null OR Vlprepap = 0
                        #region if10
                        if (!ordemValidar.Preco.HasValue || ordemValidar.Preco == 0)
                        {
                            //                Return TRUE
                            return true;
                        }
                        //            Else
                        else
                        {
                            //                If bEPop   TIPO MERCADO IGUAL A ESTRUTURADO
                            #region if11
                            if (ordemValidar.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Estruturado)
                            {
                                //                    Return TRUE
                                return true;
                            }
                            //                Else
                            else
                            {
                                //                    Call fDisplayError( 'Preço do papel deve ser nulo.' )
                                validationException.AddError(ERRO_ORDEM_PRECOTITULOINVALIDO_03); //"Preço do papel deve ser nulo."
                                //                    Return FALSE
                                return false;
                            }
                            #endregion if11
                        }
                        #endregion if10
                    }
                    #endregion if08
                }
                #endregion if07
            }
            #endregion if01
        }

        /// <summary>
        /// Campo "Valor" do painel "Financiamento"
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarVlFinanc(BusinessEntity.Ordem ordemValidar)
        {
            //If TipordF = 'S' 
            if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento))
            {
                //    If VlFinanc = NUMBER_Null
                if (!ordemValidar.ValorFinanciado.HasValue)
                {
                    //        Call fDisplayError( 'Valor do financiamento não pode ser nulo.' )
                    validationException.AddError(ERRO_ORDEM_VALORFINANCIAMENTONULO); //"Valor do financiamento não pode ser nulo."
                    //        Return FALSE
                    return false;
                }
            }

            //Return TRUE
            return true;
        }
        
        /// <summary>
        /// Campo "Carteira"
        /// Autor: Eduardo Sertorio
        /// Data: 06/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns>bool</returns>
        private bool ValidarCdcarliq(BusinessEntity.Ordem ordemValidar)
        {
            Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado tMercado;

            //If (TipordF = 'S')  AND  (bOrdemMae = TRUE)
            if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                && bOrdemMae)
            {
                //    Call fChangeNumberAttribute( 'Cdcarliq', 0 )
                ordemValidar.CodigoCarteira = 0;
                //    Return TRUE
                return true; //incluido - esertorio - 200804161542 - ref issue ID0003225
            }
            //!
            //! Se é POP  TIPO DE MERCADO ESTRUTURADO
            //If SalStrMidX( Cdcodisi, 6, 2 ) = 'PP'
            //if(ordemValidar.CodigoISIN.Substring(6,2) == "PP")
            if (VerificarOrdemPOP(ordemValidar))
            {
            //    Call fChangeNumberAttribute( 'Cdcarliq', 277 )
                ordemValidar.CodigoCarteira = 277;
            }
            //!
            //If Cdmercad != 'OPC'
            if (ordemValidar.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra)
            {
                //    Set sMer = Cdmercad
                tMercado = ordemValidar.TipoMercado.Value;
            }
            //Else
            else
            {
            //    If sGMerc = ''
                if (pTituloIncluir == null)
            //        Call ValidarCdnegsp()  -- ATRIBUI VALOR SGMERC
                    ValidarCdnegsp(ordemValidar);

            //    Set sMer = sGMerc
                tMercado =  (TipoMercado)  pTituloIncluir.TipoMercado.Value;
            }

            //Call oCarteira.Inicializa(Cdcarliq,Inliquida,0,0,0,sMer,Cdnatope,Cdbolsa)

            //If Cdcarliq = NUMBER_Null
            if (!ordemValidar.CodigoCarteira.HasValue)
            {
                //    Call fChangeNumberAttribute( 'Cdcarliq', oCarteira.fGetCarteira() )
                ordemValidar.CodigoCarteira = ValidacaoCarteiraFGetCarteira(ordemValidar);
            }

            //Call oCarteira.Inicializa(Cdcarliq,Inliquida,0,0,0,sMer,Cdnatope,Cdbolsa)

            //Return oCarteira.ValidaExistencia() 
            return ValidacaoCarteiraValidaExistencia(ordemValidar);
        }

        /// <summary>
        /// Representa classe ValidacaoCarteira com metodo FGetCarteira()
        /// Autor: Eduardo Sertorio
        /// Data: 07/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private int? ValidacaoCarteiraFGetCarteira(BusinessEntity.Ordem ordemValidar)
        {
            BusinessEntity.MercadoCarteira beMercadoCarteiraRequest = new BusinessEntity.MercadoCarteira();

            beMercadoCarteiraRequest.Mercado.TipoMercado = ordemValidar.TipoMercado.Value;
            beMercadoCarteiraRequest.NaturezaOperacao = ordemValidar.NaturezaOperacao.Value;
            beMercadoCarteiraRequest.Bolsa = ordemValidar.Bolsa;

            return (new Ordens.ResourceAccess.Carteira()).ConsultarCarteiraComPrioridade(beMercadoCarteiraRequest);
        }

        /// <summary>
        /// Representa classe ValidacaoCarteira com metodo ValidaExistencia()
        /// Autor: Eduardo Sertorio
        /// Data: 07/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidacaoCarteiraValidaExistencia(BusinessEntity.Ordem ordemValidar)
        { 
            //If CdCarliq = NUMBER_Null
            if (!ordemValidar.CodigoCarteira.HasValue)
            {
                //    Call SalMessageBox (  'Carteira não pode ser nula !' , 'Atenção', MB_Ok | MB_IconExclamation )
                validationException.AddError(ERRO_ORDEM_CARTEIRANULO); //"Carteira não pode ser nula !"
                //    Return FALSE
                return false;
            }

            //If Not VerificaCarteira ( )
            if (!ValidacaoCarteiraVerificaCarteira(ordemValidar))
            {
                //    Call SalMessageBox ( 'Carteira não existe para Mercado/Natureza/Bolsa !' , 'Atenção', MB_Ok | MB_IconExclamation )
                validationException.AddError(ERRO_ORDEM_CARTEIRAINVALIDO); //"Carteira não existe para Mercado/Natureza/Bolsa !"
                //    Return FALSE
                return false;
            }

            //Return TRUE
            return true;
        }

        /// <summary>
        /// Representa classe ValidacaoCarteira com metodo VerificaCarteira()
        /// Autor: Eduardo Sertorio
        /// Data: 07/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool ValidacaoCarteiraVerificaCarteira(BusinessEntity.Ordem ordemValidar)
        {
            int? carteira = null;

            carteira = (new Ordens.ResourceAccess.Carteira()).ConsultarPorCodigo(
                ordemValidar.CodigoCarteira, 
                ordemValidar.TipoMercado.Value, 
                ordemValidar.NaturezaOperacao.Value, 
                ordemValidar.Bolsa);

            return (ordemValidar.CodigoCarteira == carteira);
        }
        
        /// <summary>
        ///  CAMPO VALIDADE DA ORDEM
        /// Autor: Eduardo Sertorio
        /// Data: 07/01/2008
        /// </summary>
        private bool ValidarDataAte(BusinessEntity.Ordem ordemValidar)
        {
            //If ValidarInAdminCon()
            if (ValidarInAdminCon(ordemValidar))
            {
                //    If InAdminCon = 'S'
                if (ordemValidar.IndicadorOrdemAbertaAdminCon.Value)
                {
                    //        Call fChangeDateAttribute( 'Dtperval', Dtdatord )
                    ordemValidar.DataValidade = ordemValidar.DataOrdem;
                }
            }

            //!
            //If Dtperval = DATETIME_Null 
            if (!ordemValidar.DataValidade.HasValue)
            {
                //    Call fChangeDateAttribute ( 'Dtperval', Dtdatord )
                ordemValidar.DataValidade = ordemValidar.DataOrdem;
            }
            //Else
            else
            {
                //    If bOrdemMae
                if (bOrdemMae)
                {
                    //        If Dtdatord > Dtperval  (DATA DA VALIDADE DA ORDEM)
                    if (ordemValidar.DataOrdem > ordemValidar.DataValidade)
                    {
                        //            Call fDisplayError( 'Data de validade da ordem inválida !' )
                        validationException.AddError(ERRO_ORDEM_DATAVALIDADEINVALIDO); //"Data de validade deve ser igual ou posterior a data da ordem."
                        //            Return FALSE
                        return false;
                    }
                }
            }

            /// Data:22/01/2008 15:03
            /// Autor:DMilanez.7Comm 
            /// Obs: Correcao
            /// Executar apenas Se estiver realizando o update da ordem
            if (ordemValidar.NumeroOrdem.HasValue)
            {
                //!
                //Set sComando = "
                //        Select to_char(dt_negocio,'dd/mm/yyyy')
                //          into :sPregao
                //          from torcomi
                //         where nr_seqord  = :Nrseqord
                //           and dt_negocio > :Dtperval
                //         order by dt_negocio desc"
                //When SqlError
                //    Call SqlGetError( fGetSqlHandle(), nErro, sErro )
                //Call SqlPrepareAndExecute( fGetSqlHandle(), sComando )
                //If nErro != 0
                //    Call fDisplayError( SalNumberToStrX( nErro, 0 )||' - '||sErro )
                //    Return FALSE
                //Call SqlFetchNext( fGetSqlHandle(), nRet )
                DateTime? dataPregao = (new ResumoFinanceiro.ResourceAccess.Comitente())
                    .RecuperarMaiorDataNegocioComitente(ordemValidar.NumeroOrdem.Value, ordemValidar.DataValidade.Value);

                //If nRet = FETCH_Ok
                if (dataPregao.HasValue)
                {
                    //    Call fDisplayError( 'Data de validade da Ordem deve ser maior ou igual a '||sPregao||
                    //                                ' pois existem negócio(s) deste pregão casado(s) nesta Ordem!' )
                    //string msg = "Data de validade da Ordem deve ser maior ou igual a " 
                    //    +  Sinacor.Servico.Bovespa.BovespaBase.Service.Util.Funcoes.FormatarData(dataPregao.Value,"/") 
                    //    + " pois existem negócio(s) deste pregão casado(s) nesta Ordem!";

                    validationException.AddError(ERRO_ORDEM_DATAVALIDADEMENORDATANEGOCIOCASADO); //"Data de validade da Ordem deve ser maior ou igual aa maior data do(s) negocio(s) já casado(s) para essa ordem."
                    //    Return FALSE
                    return false;
                }
            }
            //!
            //Return TRUE
            return true;
        }

        /// <summary>
        /// Validar campo "InAdminCon"
        /// Data: 07/01/2008
        /// Autor: Eduardo Sertorio
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool ValidarInAdminCon(BusinessEntity.Ordem ordemValidar)
        { 
            bool bClienteInAdminCon = false;

            //If InAdminCon = ''
            if (!ordemValidar.IndicadorOrdemAbertaAdminCon.HasValue)
            {
                //    !
                //    Set sCmd = "
                //            select 0
                //              from tbocarpro a,
                //                   tscclibol b
                //             where a.cd_cliente  = :Cdcliente
                //               and b.cd_cliente  = a.cd_cliente
                //               and a.tp_cliente  = 'A'
                //               and b.in_admincon = 'S'"
                //    !
                //    Set nErro = 0
                //    !
                //    When SqlError
                //        Call SqlGetError( fGetSqlHandle(), nErro, sErro )
                //        Return TRUE
                //    Call SqlPrepareAndExecute( fGetSqlHandle(), sCmd )
                //    !
                //    If nErro != 0
                //        Call fDisplayError( SalNumberToStrX( nErro, 0 )||' - '||sErro )
                //        Return FALSE
                //    !

                //    Call SqlFetchNext( fGetSqlHandle(), nRet )
                bClienteInAdminCon = (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).ValidarClienteAdminCon(ordemValidar.CodigoCliente.Value);
                //    !
                //    If nRet = FETCH_EOF
                if (!bClienteInAdminCon)
                    //        Call fChangeStrAttribute( 'InAdminCon', 'N' )
                    ordemValidar.IndicadorOrdemAbertaAdminCon = false;
                //    Else
                else
                {
                    //        Call fChangeStrAttribute( 'InAdminCon', 'S' )
                    ordemValidar.IndicadorOrdemAbertaAdminCon = true;
                    //        !
                    //        Call fChangeStrAttribute( 'TipordD', 'S' )
                    if (!ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria))
                        ordemValidar.TipoOrdem.Add(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria);

                    //        If TipordF != 'S'
                    if (!ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento))
                    {
                        //            Call fChangeStrAttribute( 'TipordA', 'S' )
                        if (!ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Administrada))
                            ordemValidar.TipoOrdem.Add(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Administrada);
                        //            Call fChangeStrAttribute( 'TipordM', 'N' )
                        ordemValidar.TipoOrdem.Remove(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Mercado);
                        //            Call fChangeStrAttribute( 'TipordC', 'N' )
                        ordemValidar.TipoOrdem.Remove(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Casada);
                        //            Call fChangeStrAttribute( 'TipordL', 'N' )
                        ordemValidar.TipoOrdem.Remove(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada);
                        //            Call fChangeStrAttribute( 'TipordO', 'N' )
                        ordemValidar.TipoOrdem.Remove(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.OnStop);
                    }
                }
            }
            //!
            //Return ValidarTipoOrdem();
            return ValidarTipoOrdem(ordemValidar);
        }

        /// <summary>
        /// Validar campo "Tipo da Ordem"
        /// Data: 07/01/2008
        /// Autor: Eduardo Sertorio
        /// </summary>
        /// <param name="ordemValidar">BusinessEntity.Ordem</param>
        /// <returns>bool</returns>
        private bool ValidarTipoOrdem(BusinessEntity.Ordem ordemValidar)
        { 
            //Set nQtd = 0
            int nQtd = 0;
            string sParte1 = "";
            string sParte2 = "";
            string sParte3 = "";

            /*
             * teste
            List<Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem> lst = new List<Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem>();
            lst.Add(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria);
            lst.Add(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Mercado);
            lst.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada);
             * 
             */

            //If TipordM  = 'S'
            if(ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Mercado))
            {
                //    Set nQtd = nQtd + 1
                nQtd = nQtd + 1;
                //    If nQtd = 1
                if (nQtd == 1)
                    //        Set sParte1 = '1'
                    sParte1 = "1";
                //    Else
                else
                    //        Set sParte2 = '1'
                    sParte2 = "1";
            }

            //If TipordC  =  'S'
            if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Casada))
            {
                //    Set nQtd = nQtd + 1
                nQtd = nQtd + 1;
                //    If nQtd = 1
                if (nQtd == 1)
                //        Set sParte1 = '2'
                    sParte1 = "2";
                //    Else
                else
                //        Set sParte2 = '2'
                    sParte2 = "2";
            }

            //If TipordA  =  'S'
            if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Administrada))
            {
                //    Set nQtd = nQtd + 1
                nQtd = nQtd + 1;
                //    If nQtd = 1
                if (nQtd == 1)
                    //        Set sParte1 = '3'
                    sParte1 = "3";
                //    Else
                else
                //        Set sParte2 = '3'
                    sParte2 = "3";
            }

            //If TipordL  =  'S'
            if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada))
            {
                //    Set nQtd = nQtd + 1
                nQtd = nQtd + 1;
                //    If nQtd = 1
                if (nQtd ==1)
                //        Set sParte1 = '5'
                    sParte1 = "5";
                //    Else
                else
                //        Set sParte2 = '5'
                    sParte2 = "5";
            }

            //If TipordF  =  'S'
            if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento))
            {
                //    Set nQtd = nQtd + 1
                nQtd = nQtd + 1;
                //    If nQtd = 1
                if (nQtd == 1)
                    //        Set sParte1 = '6'
                    sParte1 = "6";
                //    Else
                else
                    //        Set sParte2 = '6'
                    sParte2 = "6";
            }

            //If TipordO  =  'S'
            if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.OnStop))
            {
                //    Set nQtd = nQtd + 1
                nQtd = nQtd + 1;
                //    If nQtd = 1
                if (nQtd.Equals(1))
                    //        Set sParte1 = '7'
                    sParte1 = "7";
                //    Else
                else
                    //        Set sParte2 = '7'
                    sParte2 = "7";
            }

            //If TipordD  =  'S'
            if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria))
            {
                //    Set nQtd = nQtd + 1
                nQtd = nQtd + 1;
                //    If nQtd = 1
                if (nQtd.Equals(1))
                    //        Set sParte1 = '4'
                    sParte1 = "4";
                //    Else
                else
                    //        Set sParte2 = '4'
                    sParte2 = "4";
            }

            //If Not ( ValidarNrqtdord ( ) and ValidarCdnegsp ( ) and
            //                      ValidarCdnatope ( ) and ValidarCdmercad ( ) and ValidarVlFinanc ( ) )
            if (!ValidarNrqtdord(ordemValidar))
                return false;

            if (!ValidarCdnegsp(ordemValidar))
                return false;

            if (!ValidarCdnatope(ordemValidar))
                return false;

            if (!ValidarCdmercad(ordemValidar))
                return false;

            if (!ValidarVlFinanc(ordemValidar))
                return false;


            //If nQtd = 0
            if (ordemValidar.TipoOrdem.Count.Equals(0)) //(nQtd.Equals(0))
            {
                //    Call fDisplayError( 'Tipo de ordem não pode ser nulo.' )
                validationException.AddError(ERRO_ORDEM_TIPOORDEMNULO); //"Tipo de ordem não pode ser nulo."
                //    Return FALSE
                return false;
            }

            //If nQtd = 1 and TipordD  =  'S'
            if (ordemValidar.TipoOrdem.Count.Equals(1) //(nQtd.Equals(1))
                && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria))
            {
                //    Call fDisplayError( 'Ordens Discricionárias devem estar acompanhadas de outro tipo')
                validationException.AddError(ERRO_ORDEM_TIPOORDEMINVALIDO_01); //"Ordens Discricionárias devem estar acompanhadas de outro tipo."
                //    Return FALSE
                return false;
            }

            //If nQtd >1
            if (ordemValidar.TipoOrdem.Count > 1) //(nQtd > 1)
            {
                int iParte1 = 0;
                int iParte2 = 0;
                Int32.TryParse(sParte1, out iParte1);
                Int32.TryParse(sParte2, out iParte2);

                //    If sParte1 > sParte2
                if (iParte1 > iParte2)
                {
                    //        Set sParte3 = sParte2
                    sParte3 = sParte2;
                    //        Set sParte2 = sParte1
                    sParte2 = sParte1;
                    //        Set sParte1 = sParte3
                    sParte1 = sParte3;
                }
            }

            //If nQtd = 2 
            if (ordemValidar.TipoOrdem.Count.Equals(2)) //(nQtd.Equals(2))
            {
                //    If TipordA = 'S' or TipordD = 'S'
                if (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Administrada)
                    || ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria))
                {
                    //        Return TRUE
                    return true;
                }
                //    Else
                else
                {
                    //        Call fDisplayError( 'Somente Ordens Discricionárias ou Administradas podem estar acompanhadas de outro tipo')
                    validationException.AddError(ERRO_ORDEM_TIPOORDEMINVALIDO_02); //"Somente Ordens Discricionárias ou Administradas podem estar acompanhadas de outro tipo."
                    //        Return FALSE
                    return false;
                }
            }

            //If nQtd > 2
            if (ordemValidar.TipoOrdem.Count > 2) //(nQtd > 2)
            {
                //    Call fDisplayError( 'Escolha no Maximo dois Tipos de ordem !.' )
                validationException.AddError(ERRO_ORDEM_TIPOORDEMINVALIDO_03); //"Escolha no Maximo dois Tipos de ordem !."
                //    Return FALSE
                return false;
            }

            //Return TRUE
            return true;            
        }

        /// <summary>
        /// Campo "Bolsa"
        /// Autor: Eduardo Sertorio
        /// Data: 07/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns>bool</returns>
        private bool ValidarCdbolsa(BusinessEntity.Ordem ordemValidar)
        {
            string sPraca = null;
            //If Cdbolsa=''
            if (String.IsNullOrEmpty(ordemValidar.Bolsa))
            {
            //    Call SqlPrepareAndExecute( hSqlGeral, "select 
            //                   b.cd_bolsa
            //                   FROM TGEUSUARIO  A,TGELOCAL b, TGEBOLSA c, TGEUSUEMP d
            //                   WHERE A.CD_USUARIO   = :Cdcodusu
            //                and d.cd_usuario	= a.cd_usuario
            //                          and b.cd_empresa     = d.cd_empresa
            //                          and c.cd_bolsa          = b.cd_bolsa
            //                          and IN_PRAC_PRINC = 'S'
            //                     into :sPraca
            //                   order by b.cd_bolsa" )
            //    Call SqlFetchNext( hSqlGeral,nStatus )
                sPraca = (new Ordens.ResourceAccess.Bolsa()).ConsultarPorUsuario(ordemValidar.CodigoUsuarioConectado.Value);

                //    If sPraca = ''
                if (String.IsNullOrEmpty(sPraca))
                {
                    //        Call fDisplayError( 'Bolsa não pode ser nula !' )
                    validationException.AddError(ERRO_ORDEM_BOLSANAOCADASTRADAPARAUSUARIO); //"Bolsa não pode ser nula !"
                    //        Return FALSE
                    return false;
                }

                //    Call fChangeStrAttribute ( 'Cdbolsa', sPraca)
                ordemValidar.Bolsa = sPraca;

                //If sPraca != '1'
                if (sPraca != "1")
                {
                    //    Return ValidarCdcliente( )
                    return ValidarCdcliente(ordemValidar);
                }
            }

            //Return TRUE
            return true;
        }

        /// <summary>
        /// Campo "Vencimento do Termo"
        /// Autor: Eduardo Sertorio
        /// Data: 07/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarTpVctoTermo(BusinessEntity.Ordem ordemValidar)
        { 
            //If TipordF = 'S' and Nrsubseq != 0 and Cdmercad = 'TER' and Nrsubseq != NUMBER_Null
            if (
                //&& ordemValidar.NumeroOrdemSubSequencia != null //nao se aplica pq atributo nao aceita nulo - DMilanez.7Comm - 23/01/2008 17:42
                   ordemValidar.NumeroOrdemSubSequencia != null //condição recolocada porque atributo aceita nulo - esertorio - 200804132011 - ref issue ID0003159
                && !ordemValidar.NumeroOrdemSubSequencia.Equals(0)
                && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                && ordemValidar.TipoMercado.Value.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo)
                )
            {
                /// Data:23/01/2008 17:42
                /// Autor:DMilanez.7Comm
                /// Obs: Correcao
                /// Alterado para n estourar erro quando o codigo do titulo
                /// tiver menos que 6 caracteres
                /// da forma como passou a ser codificado, é recuperado a parte numerica do 
                /// 
                //    Set nParNum = SalStrToNumber (SalStrMidX( Cdnegsp, 4, 2 ))
                //int nParNum = Int32.Parse(ordemValidar.Titulo.Substring(4, 2));
                Regex r = new Regex(@"\d");
                int nParNum = Int32.Parse(r.Match(ordemValidar.Titulo).Value);

                //    If nParNum > 50
                if (nParNum > 50)
                {
                    //        If TpVctoTermo != NUMBER_Null  CAMPO VENCIMENTO DO TERMO
                    if (ordemValidar.VencimentoTermo.HasValue)
                    {
                        //            Call fDisplayError( 'Tipo em ponto não deve ter vencimento.' )
                        validationException.AddError(ERRO_ORDEM_VENCIMENTOTERMOINVALIDO_02); //"Tipo em ponto não deve ter vencimento."
                        //            Return FALSE
                        return false;
                    }
                    //        Else
                    else
                    {
                        //            Return TRUE
                        return true;
                    }
                }
                //    Else
                else
                {
                    //        If TpVctoTermo = NUMBER_Null
                    if (!ordemValidar.VencimentoTermo.HasValue)
                    {
                        //            Call fDisplayError( 'Termo deve ter vencimento.' )
                        validationException.AddError(ERRO_ORDEM_VENCIMENTOTERMONULO_02); //"Termo deve ter vencimento."
                        //            Return FALSE
                        return false;
                    }
                    //        Else
                    else
                    {
                        //            If Not ValidarPrazoTer ( TpVctoTermo )
                        if (ValidarPrazoTer(ordemValidar))
                        {
                            //                Call fDisplayError( 'Tipo de vencimento termo deve ser múltiplo de 30.' )
                            validationException.AddError(ERRO_ORDEM_VENCIMENTOTERMOINVALIDO_03); //"Tipo de vencimento termo deve ser múltiplo de 30."
                            //                Return FALSE
                            return false;
                        }
                    }
                }
            }

            //Return TRUE
            return true;
        }

        /// <summary>
        /// Campo "Anexo V"
        /// Autor: Eduardo Sertorio
        /// Data: 07/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarNrqtdAnV(BusinessEntity.Ordem ordemValidar)
        {
            //If NrqtdAnV = NUMBER_Null
            if (!ordemValidar.QuantidadeAnexo5.HasValue)
            {
                //    Call fChangeNumberAttribute('NrqtdAnV', 0)
                ordemValidar.QuantidadeAnexo5 = 0;
            }

            //If NrqtdAnIV = NUMBER_Null
            if (!ordemValidar.QuantidadeAnexo4.HasValue)
            {
                //    Call fChangeNumberAttribute('NrqtdAnIV', 0)
                ordemValidar.QuantidadeAnexo4 = 0;
            }

            //If NrqtdAnV + NrqtdAnIV  > Nrqtdord 
            if ((ordemValidar.QuantidadeAnexo5 + ordemValidar.QuantidadeAnexo4) > ordemValidar.Quantidade)
            {
                //    Call fDisplayError( 'Quantidade de Anexo V, Anexo IV maior que a Ordem.' )
                validationException.AddError(ERRO_ORDEM_QTDEANEXOSMAIORQTDEORDEM_01); //"Quantidade de Anexo V, Anexo IV maior que a Ordem."
                //    Return FALSE
                return false;
            }

            //Return TRUE
            return true;
        }
        
        /// <summary>
        /// Campo "Anexo IV"
        /// Autor: Eduardo Sertorio
        /// Data: 07/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarNrqtdAnIV(BusinessEntity.Ordem ordemValidar)
        {
            //If NrqtdAnV = NUMBER_Null
            if (!ordemValidar.QuantidadeAnexo5.HasValue)
            {
                //    Call fChangeNumberAttribute('NrqtdAnV', 0)
                ordemValidar.QuantidadeAnexo5 = 0;
            }

            //If NrqtdAnIV = NUMBER_Null
            if (!ordemValidar.QuantidadeAnexo4.HasValue)
            {
                //    Call fChangeNumberAttribute('NrqtdAnIV', 0)
                ordemValidar.QuantidadeAnexo4 = 0;
            }

            //If NrqtdAnV + NrqtdAnIV  > Nrqtdord 
            if ((ordemValidar.QuantidadeAnexo4 + ordemValidar.QuantidadeAnexo5) > ordemValidar.Quantidade)
            {
                //    Call fDisplayError( 'Quantidade de Anexo V, Anexo IV maior que a Ordem.' )
                validationException.AddError(ERRO_ORDEM_QTDEANEXOSMAIORQTDEORDEM_02); //"Quantidade de Anexo V, Anexo IV maior que a Ordem."
                //    Return FALSE
                return false;
            }

            //Return TRUE
            return true;
        }

        #region FONTE CEZAR

        /// <summary>
        /// Campo "Dolar"
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>        
        private bool ValidarVlDolar(BusinessEntity.Ordem ordemValidar)
        {
            //If VlDolar = NUMBER_Null
            if (!ordemValidar.Cambio.HasValue)
            {
                //Call fChangeNumberAttribute('VlDolar', 1)
                ordemValidar.Cambio = 1;
            }

            //Return TRUE
            return true;
        }

        /// <summary>
        /// Campo Nao Visivel "IndicadorTipoDistribuicao"
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// 
        /// Autor: Eduardo Sertorio
        /// Data : 27/02/2008
        /// Obs. : Incluida verificacao String.IsNullOrEmpty para evitar erro em Substring de String vazio.
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool ValidarInDistribui(BusinessEntity.Ordem ordemValidar)
        {
            if (ValidarInAdminCon(ordemValidar))
            {
                //If InAdminCon = 'S'
                if (ordemValidar.IndicadorOrdemAbertaAdminCon.Value)
                {
                    //If bEPop or SalStrMidX( Cdcodcas, 6, 2 ) = 'PP'  CDCODCAS ATRIBUIDO NA DIGITAÇÃO DO TITULO
                    if (ordemValidar.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Estruturado)
                        || (!String.IsNullOrEmpty(ordemValidar.CodigoCasamento)
                            && ordemValidar.CodigoCasamento.Substring(6, 2).Equals("PP")
                            )                            
                        )
                    {
                        //Call fDisplayError( 'Negociação de POP não permitida para cliente AdminCon' )
                        validationException.AddError(ERRO_ORDEM_POPINVALIDOCOMADMINCON); //"Negociação de POP não permitida para cliente AdminCon."
                        //Return FALSE
                        return false;
                    }
                    //Else
                    else
                    {
                        //Call fChangeStrAttribute( 'InDistribui', 'A' )
                        ordemValidar.IndicadorTipoDistribuicao = "A";
                    }
                }
                //Else If InDistribui = ''
                else
                {
                    if (String.IsNullOrEmpty(ordemValidar.IndicadorTipoDistribuicao))
                    {
                        //If bEPop or SalStrMidX( Cdcodcas, 6, 2 ) = 'PP'
                        if (ordemValidar.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Estruturado)
                            || ( !String.IsNullOrEmpty(ordemValidar.CodigoCasamento) //incluido - eduardo sertorio - 200802271808
                                && ordemValidar.CodigoCasamento.Substring(6, 2).Equals("PP")
                                )
                            )
                        {
                            //Call fChangeStrAttribute( 'InDistribui', 'N' )
                            ordemValidar.IndicadorTipoDistribuicao = "N";
                        }
                        //Else
                        else
                        {
                            //Call fChangeStrAttribute( 'InDistribui', 'S' )
                            ordemValidar.IndicadorTipoDistribuicao = "S";
                        }
                    }
                }
            }
            else
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// Campo Nao Visivel "QuantidadeCanceladaOferta"
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarQtCancofe(BusinessEntity.Ordem ordemValidar)
        {
            if (ordemValidar.QuantidadeCanceladaOferta == null)
            {
                ordemValidar.QuantidadeCanceladaOferta = 0;
            }
            return true;
        }

        /// <summary>
        /// Campo "No." (Numero Sequencia da Ordem)
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool ValidarNrSeqordOri(BusinessEntity.Ordem ordemValidar)
        {
            // nao se aplica porque atributo [NumeroOrdemSubSequencia] nao aceita nulo. //eduardo - 20080111
            //if (ordemValidar.NumeroOrdemSubSequencia == null)
            //{
            //    ordemValidar.NumeroOrdemSubSequencia = 0;
            //}
            return true;
        }

        /// <summary>
        /// Campo "Vencimento do Termo" - validacao adicional
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool ValidarPrazoTer(BusinessEntity.Ordem ordemValidar)
        {
            //! Set nDivisor = SalNumberMod( PrazoTer, 30 ) //PrazoTer = Vencimento do Termo
            //! Alterado em 14/04/2000 para atender a nova regra
            //! de prazo do termo na Bovespa
            int nDivisor = (ordemValidar.VencimentoTermo.Value % 1);
            if (nDivisor == 0)
                return true;
            else
                return false;
        }

        /// <summary>
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool ValidarOpcoes(BusinessEntity.Ordem ordemValidar)
        {
		    //If sGMerc = 'OPC' OR sGMerc = 'OPV' 
            if (ordemValidar.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra)
                || ordemValidar.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda))
            {
			    //Call fChangeStrAttribute('Cdmercad', sGMerc)
                ordemValidar.TipoMercado = ordemValidar.TipoMercado;
            }
		    //Return TRUE
            return true;
        }

        /// <summary>
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool ValidarLoteOpcao(BusinessEntity.Ordem ordemValidar)
        {
            if (ValidarLoteOpcaoNova(ordemValidar))
            {
                return true;
            }
            else
            {
                validationException.AddError(ERRO_ORDEM_OPCOESFUTUROFORALOTEPADRAO); //"Ordem de Opções/Futuro fora do Lote Padrão"
                return false;
            }
        }

        /// <summary>
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool ValidarLoteOpcaoNova(BusinessEntity.Ordem ordemValidar)
        {
            //If (sMercado != 'OPC')  and (sMercado != 'OPV') and (sMercado != 'FUT')
            if (!ordemValidar.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda) 
                && !ordemValidar.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra) 
                && !ordemValidar.TipoMercado.Equals(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Futuro))
                //Return TRUE
                return true;

            //If sBolsa != '1'
            if (!ordemValidar.Bolsa.Equals("1"))
                //Return TRUE
                return true;

            //If nQtdord = NUMBER_Null or nQtdord = 0
            if (!ordemValidar.Quantidade.HasValue 
                || ordemValidar.Quantidade.Value.Equals(0))
                //Return TRUE
                return true;

            Titulo.BusinessEntity.Titulo beTituloRequest = new Titulo.BusinessEntity.Titulo();
            beTituloRequest.Codigo = ordemValidar.Titulo;
            beTituloRequest.DataPregao = ordemValidar.DataOrdem.Value; //corrigido de (ordemValidar.DataPregao) para (ordemValidar.DataOrdem) - esertorio - 200804112111 - ref issue ID0002954
            Titulo.BusinessEntity.Titulo beTituloResponse = (new Titulo.ResourceAccess.Titulo()).ConsultarTituloLote(beTituloRequest);

            //If nLote = 0
            if (beTituloResponse != null) //corrigido - esertorio - 200804112212 - ref issue ID0002954
                if (!beTituloResponse.TituloLote.NumeroLoteNegociacao.HasValue //corrigido - esertorio - 200804112212 - ref issue ID0002954
                    || beTituloResponse.TituloLote.NumeroLoteNegociacao.Value.Equals(0))
                    //Return FALSE
                    return false;

            //Set nResto =  SalNumberMod(nQtdord,nLote)
            //If nResto != 0
            if ((ordemValidar.Quantidade.Value % beTituloResponse.TituloLote.NumeroLoteNegociacao) != 0)
                //Return FALSE
                return false;

            //O TRECHO DE CODIGO CENTURA ATÉ AQUI ESTAVA COMENTANDO (!), POR ISSO FOI IGNORADO;
            //Return TRUE
            return true;
        }

        /// <summary>
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool ExisteBloqueio(BusinessEntity.Ordem ordemValidar)
        {
		    //If Insituac = 'D'
            if (ordemValidar.Situacao == "D")
                //Return FALSE
                return false;
            //Else
            else
            {
                //Call oEstadoMovimento.fBuscaDataMovimento( fGetSqlHandle( ), dtDataDia, dtDataPreg )
                //BuscaDataMovimento(ref dtDataDia, ref dtDataPreg.Value);
                DateTime dtDataPreg = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();

                //If Dtperval < dtDataPreg
                if (ordemValidar.DataValidade < dtDataPreg)
                    //Set dtDataPreg = Dtperval
                    dtDataPreg = ordemValidar.DataValidade.Value;

                //Set sDataPreg = SalFmtFormatDateTime( dtDataPreg, 'dd/MM/yyyy' )
                //Set sComando = "
                //        begin
                //           if pOr_Bloqueio.fOr_Exis_Bloq( :nCodCli, :sTipoMerc, :sNatOpe, :sCodNeg, :sDataPreg, :srTipoBloq, :srDescBloq ) then
                //              :sBloqueado := 'S';
                //           else
                //              :sBloqueado := 'N';
                //           end if;
                //        end;"

                Sinacor.Servico.Bovespa.Cliente.BusinessEntity.BloqueioCliente beBloqueioClienteRequest = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.BloqueioCliente();

                beBloqueioClienteRequest.CodigoCliente = ordemValidar.CodigoCliente.Value;
                beBloqueioClienteRequest.Mercado = (Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoMercado) ordemValidar.TipoMercado.Value;
                beBloqueioClienteRequest.NaturezaOperacao = (Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoNaturezaOperacao) ordemValidar.NaturezaOperacao; //alterado para retirar (Value) de (NaturezaOperacao) - esertorio - 200804162128 - ref issue ID0003223
                beBloqueioClienteRequest.CodigoNegocio = ordemValidar.Titulo; //titulo
                beBloqueioClienteRequest.DataPregao = dtDataPreg;

                Sinacor.Servico.Bovespa.Cliente.BusinessEntity.BloqueioCliente beBloqueioClienteResponse = (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).VerificarBloqueioCliente(beBloqueioClienteRequest);

                //If sBloqueado = 'S'
                if (beBloqueioClienteResponse.isBloqueado)
                {
                    //    Call SalMessageBox( '(' || srTipoBloq || ') ' || srDescBloq, 'Atenção - Bloqueio', MB_Ok )
                    ordemValidar.BloqueioCliente = beBloqueioClienteResponse;
                    return true;
                }
                else
                {
                    ordemValidar.BloqueioCliente = null;
                    return false;
                }
                //    Return TRUE
            }
        }

        /// <summary>
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// </summary>
        /// <returns></returns>
        private void BuscaDataMovimento(ref DateTime? dataDia, ref DateTime? dataMovimento)
        {
            //Description:
            //Returns
            //    Boolean:
            //Parameters
            //    Sql Handle: hSqlMov
            //    Receive Date/Time: dpDataDia
            //    Receive Date/Time: dpDataMov
            //Static Variables
            //Local variables
            //    String: sComando
            //    Date/Time: dDataDia
            //    Date/Time: dDataMov
            //Actions
            //Set sComando = 'Select dt_datmov, sysdate
            //                into :dDataMov, :dDataDia
            //                from tordatmov'
            //Call SqlPrepareAndExecute( hSqlMov, sComando )
            //Call SqlFetchNext( hSqlMov, wParam )
            //If wParam = FETCH_EOF
            //    Return FALSE
            //Else
            //    Set dpDataDia = dDataDia
            //    Set dpDataMov = dDataMov
            //    Return TRUE

            dataDia = (new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarDataSistemaBancoDados();
            dataMovimento = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();
        }

        /// <summary>
        /// Autor: Cezar P. / Eduardo Sertorio
        /// Data: 08/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool VeriSaldNgcv(BusinessEntity.Ordem ordemValidar)
        {
            bool Existe = false;
            decimal nQtde;
            if (ordemValidar.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Venda)
                nQtde = ordemValidar.Quantidade.Value * -1M;
            else
                nQtde = ordemValidar.Quantidade.Value;
            /*
            //Set sComando = "
            //declare
            //   cursor parm is
            //      select nvl(in_veri_sald_ngcv,'N')
            //        from torparm;
            //   V_sInVeriSaldNgcv torparm.in_veri_sald_ngcv%type;
            //begin
            //   open parm;
            //   fetch parm into V_sInVeriSaldNgcv;
            //   close parm;
            //   if V_sInVeriSaldNgcv = 'S' then
            //      if :sNatOpe = 'V' then
            //         if pOr_Veri_Sald.fOr_Exis_Sald( :nCodCli, :sCodNeg, :sTipoMerc, :nQtde, :sMensagem ) then
            //            :sExiste := 'S';
            //         else
            //            :sExiste := 'N';
            //         end if;
            //      end if;
            //   else
            //      :sExiste := 'S';
            //   end if;
            //end;"
            !
            */
            Sinacor.Servico.Bovespa.Ordens.BusinessEntity.MensagemValidacao mensagemValidacaoSaldo = new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.MensagemValidacao();
            string _InVeriSalsNgcv = (new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarIndicadorVerificacaoSaldoNegociavel(); //alterado - esertorio - 200804162123 - ref issue ID0003223
            if (_InVeriSalsNgcv.Equals("S")
                && (ordemValidar.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Venda)) //alterado para retirar (Value.Equals) de (NaturezaOperacao) que pode ser nulo - esertorio - 200804162123 - ref issue ID0003223
            {
                mensagemValidacaoSaldo.Codigo = 0;
                mensagemValidacaoSaldo.Descricao = (new ResourceAccess.Ordem()).VerficarSaldoNegociavel(ordemValidar);

                Existe = !String.IsNullOrEmpty(mensagemValidacaoSaldo.Descricao);
            }
            if (!Existe)
            {
                return true;
            }
            else
            {
                //Call SalMessageBox( sMensagem, 'Verificação de Saldo em Custódia', MB_Ok | MB_IconInformation )
                ordemValidar.MensagemValidacao = mensagemValidacaoSaldo;
                return false;
            }
        }

        #endregion FONTE CEZAR

        #endregion Manutencao de Ordens - Incluir

        #region Manutencao de Ordens - Alterar

        /// <summary>
        /// Data : 09/01/2008
        /// Autor: Eduardo Sertorio / Cezar Pimentel
        /// Obs. : Criacao do metodo.
        /// 
        /// Data : 28/04/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Alterado retorno do metodo de (Boolean) para (BusinessEntity.Ordem) //alterado - esertorio - 200804281028 - ref issue ID0003694
        /// </summary>
        /// <param name="ordemAlterar"></param>
        public BusinessEntity.Ordem AlterarOrdem(BusinessEntity.Ordem ordemAlterar)
        {
            //executar
            ExecutarAlterarOrdem(ordemAlterar);

            return ordemAlterar; //incluido - esertorio - 200804281028 - ref issue ID0003694
        }

        /// <summary>
        /// Autor: Eduardo Sertorio / Cezar Pimentel
        /// Data : 09/01/2008
        /// </summary>
        /// <param name="ordemAlterar"></param>
        /// <returns></returns>
        private bool ExecutarAlterarOrdem(BusinessEntity.Ordem ordemAlterar)
        {
            bool bEPop;
            DateTime dDataMov;

            //verifica permissao para alterar ordem ("mãe", ou "capa" ou "principal")
            if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("AORD")) //incluir - eduardo sertorio - 200804241822 - ref issue ID0003474
            {
                throw new BusinessException(ERRO_ORDEM_SEMPERMISSAOALTERARORDEM); //"Usuário sem permissão para alterar ordem."  //incluido - eduardo sertorio - 200804241822 - ref issue ID0003474
            }

            /// Data : 24/01/2008
            /// Autor:Eduardo Sertorio
            /// Metodo adicionado para realizar as validacoes de campos obrigatorios antes de alterar a ordem
            ValidarObrigatoriosOrdem(ordemAlterar, "A");

            //codigo alterado de posicao para prover objeto pOrdemNaoAlterada para metodo ValidarIncluirOrdem - eduardo sertorio - 200802192112
            pOrdemNaoAlterada = ObterOrdemNaoAlterada(ordemAlterar);
            if (pOrdemNaoAlterada == null)
            {
                throw new BusinessException(ERRO_ORDEM_ORDEMINVALIDA); //"Ordem com chave inválida para alteracao."
            }

            /// Data : 17/02/2008
            /// Autor:Eduardo Sertorio
            /// Metodo adicionado para realizar as validacoes de campos obrigatorios antes de alterar a ordem
            ValidarIncluirOrdem(ordemAlterar);

            //If NrSeqordOri != 0 -- Número da Ordem Original
            if (ordemAlterar.NumeroOrdemOriginal != 0) //NrSeqordOri != 0
            {
                //Call fDisplayError( 'Ordem gerada por distribuição de Ordem AdminCon não pode ser alterada. Ordem AdminCon de origem possui nº '||SalNumberToStrX( NrSeqordOri, 0 ))
                throw new BusinessException(ERRO_ORDEM_ORDEMDISTRIBUICAOADMINCONNAOALTERAVEL); //"Ordem gerada por distribuição de Ordem AdminCon não pode ser alterada."
            }

            //nao deve ser usada Situacao vinda do usuario - eduardo - 20080120****
            ordemAlterar.Situacao = pOrdemNaoAlterada.Situacao;

            //verifica se ordem é do tipo POP (se codigo casamento contem sigla PP) - comentario incluido - eduardo sertorio - 200802192114
            bEPop = fEPop(ordemAlterar);

            //! Inclusao da permissao D1SIM com data de validade X movimento
            //! para voltar anterior basta copiar if do ultimo else e deletar o Call
            //If not fExisteFalhaNaRecepcao()
            #region if01
            if (!ExisteFalhaNaRecepcao(ordemAlterar))
            {
                //If not fExisteBloqueio( )
                #region if02
                if (!ExisteBloqueio(ordemAlterar))
                {
                    //Call oEstadoMovimento.fBuscaDataMovimento( oConexao.fGetConnect(), dDataAtu, dDataMov )
                    //BuscaDataMovimento(dDataAtu, dDataMov);
                    dDataMov = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();

                    //If dDataMov > Dtperval
                    #region if03
                    if (dDataMov > ordemAlterar.DataValidade.Value)
                    {
                        //If oAcesso.fAcesso('D1SIM')
                        #region if04
                        if (Acesso("D1SIM"))
                        {
                            //If ValidarTipoOrdem() and ...
                            #region if05
                            if (ValidarTipoOrdem(ordemAlterar)
                                && ValidarDataAte(ordemAlterar)
                                && ValidarOpcoes(ordemAlterar)
                                && ValidarVlprepap(ordemAlterar)
                                && ValidarCdcarliq(ordemAlterar)
                                && ValidarAltDeletados(ordemAlterar)
                                && ValidarLoteOpcao(ordemAlterar)
                                && ValidarNrqtdAnV(ordemAlterar)
                                && ValidarMega(ordemAlterar)
                                )
                            {
                                //sTudo = sParte1 + sParte2; //nao se aplica - 20080128
                                //nTudo = Int32.Parse(sTudo); //nao se aplica - 20080128
                                //nao se aplica - 20080128
                                //Call fChangeNumberAttribute('Nrtipord', nTudo) -- Altera o atributo tipo da ordem ( TORMOVD.TP_ORDEM ) marcando-o como alterado

                                //Call fChangeStrAttribute('Intrigger', 'S') -- Altera o atributo de disparo da trigger de log ( TORMOVD.IN_TRIGGER ) marcando-o como alterado
                                ordemAlterar.IndicadorChamadaLog = true;

                                //If Nrqtdfec > 0 -- Se quantidade executada > 0 ( TORMOVD.QT_ORDEXEC )
                                #region if06
                                if (ordemAlterar.QuantidadeCasada.Value > 0)
                                    bOrdemExe = true;
                                else
                                    bOrdemExe = false;
                                #endregion if06

                                //If Alterou()
                                #region if07
                                if (Alterou(ordemAlterar))
                                {
                                    //If Insituac = 'E'
                                    #region if08
                                    if (ordemAlterar.Situacao.Equals("E"))
                                    {
                                        throw new BusinessException(ERRO_ORDEM_ORDEMEXERCICIOAUTOMATICONAOALTERAVEL); //"Ordem de exercício automático não pode ser alterada"
                                    }
                                    else
                                    {
                                        //Else If not fOrdemComValidadeAlteravel() and Dtdatord < Dtperval
                                        #region if09
                                        if (!OrdemComValidadeAlteravel(ordemAlterar)
                                        && (ordemAlterar.DataOrdem < ordemAlterar.DataValidade))
                                        {
                                            return false;
                                        }
                                        else
                                        {
                                            //Else If ( fFinanciamento() and TipordF != 'S' ) and not bEPop -- Se Ordem originalmente era de Financiamento e foi desmarcado o tipo financiamento
                                            #region if10
                                            if ( (Financiamento() //sempre internamente com pOrdemNaoAlterada
                                                  && !ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF != "S" 
                                                  )
                                                  && !bEPop
                                                )
                                            {
                                                //If Nrsubseq = 0 -- Se é a ordem capa ( subsequência = 0 )
                                                #region if11
                                                if (ordemAlterar.NumeroOrdemSubSequencia.Equals(0))
                                                {
                                                    //If fTemFilhas()
                                                    #region if12
                                                    if (TemFilhas(ordemAlterar))
                                                    {
                                                        throw new BusinessException(ERRO_ORDEM_ORDEMFINANCIAMENTOPOPNAOALTERAVEL); //"Ordem de Financiamento ou POP não pode ser alterada - Exclua os detalhes!"
                                                    }
                                                    else
                                                    {
                                                        //Call fChangeNumberAttribute('Nrqtdfec', 0) -- Modifica atributo de quantidade executada para zero ( TORMOVD.QT_ORDEXEC )
                                                        ordemAlterar.QuantidadeCasada = 0;
                                                        //Call fChangeStrAttribute('Indistrib', 'N') -- Modifica atributo de ordem distribuída para 'N' ( TORMOVD.IN_DISTRIB )
                                                        ordemAlterar.IndicadorDistribuicao = "N";
                                                    }
                                                    #endregion if12
                                                }
                                                else
                                                {
                                                    //Call fChangeNumberAttribute('Nrqtdfec', 0) -- Modifica atributo de quantidade executada para zero ( TORMOVD.QT_ORDEXEC )
                                                    ordemAlterar.QuantidadeCasada = 0;
                                                    //Call fChangeStrAttribute('Indistrib', 'N') -- Modifica atributo de ordem distribuída para 'N' ( TORMOVD.IN_DISTRIB )
                                                    ordemAlterar.IndicadorDistribuicao = "N";
                                                }
                                                #endregion if11
                                            }
                                            else
                                            {
                                                //Call fChangeNumberAttribute('Nrqtdfec', 0) -- Modifica atributo de quantidade executada para zero ( TORMOVD.QT_ORDEXEC )
                                                ordemAlterar.QuantidadeCasada = 0;
                                                //Call fChangeStrAttribute('Indistrib', 'N') -- Modifica atributo de ordem distribuída para 'N' ( TORMOVD.IN_DISTRIB )
                                                ordemAlterar.IndicadorDistribuicao = "N";
                                            }
                                            #endregion if10
                                        }
                                        #endregion if09
                                    }
                                    #endregion if08
                                }
                                #endregion if07

                                //If fIsAttribChanged('Cdcliente') and ( TipordF = 'S' or bEPop ) -- -- Se modificou o cliente e (se ordem de Financiamento ou POP)
                                #region if13
                                if (pOrdemNaoAlterada != null 
                                    && !ordemAlterar.CodigoCliente.Value.Equals(pOrdemNaoAlterada.CodigoCarteira.Value) //IsAttribChanged("Cdcliente")
                                    && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF == "S" 
                                        || bEPop
                                        )
                                    )
                                {
                                    //If CdclienteA != Cdcliente -- se cliente diferente de cliente anterior à alteração da ordem
                                    #region if14
                                    if (pOrdemNaoAlterada != null 
                                        && !ordemAlterar.CodigoCliente.Value.Equals(pOrdemNaoAlterada.CodigoCarteira.Value))
                                    {
                                        //Set bOrdemFin = TRUE
                                        bOrdemFin = true;

                                        //If Not AlteraClienteFilhas( )
                                        #region if15
                                        if (!AlteraClienteFilhas(ordemAlterar))
                                        {
                                            throw new BusinessException(ERRO_ORDEM_ORDEMFINANCPOPFALHOUALTERACAOCLIENTE); //"Ordens de financiamento/POP não puderam ser alteradas"
                                        }
                                        else
                                        {
                                            //Call fStoreProcedureBF()
                                            StoreProcedureBF(ordemAlterar);
                                        }
                                        #endregion if15
                                    }
                                    #endregion if14
                                }
                                #endregion if13

                                //If fIsAttribChanged('Nrqtdord') and ( TipordF = 'S' or bEPop ) Se quantidade da ordem foi modificada ( TORMOVD.QT_ORDEM ) e ( Se ordem do tipo financiamento ou POP)
                                #region if16
                                if (pOrdemNaoAlterada != null 
                                    && !ordemAlterar.Quantidade.Value.Equals(pOrdemNaoAlterada.Quantidade.Value)//IsAttribChanged("Nrqtdord") 
                                    && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //(TipordF == "S" 
                                    || bEPop
                                       )
                                    )
                                {
                                    #region if17
                                    //If NrqtdordA > Nrqtdord  -- Se quantidade diferente da quantidade anterior à alteração
                                    if (pOrdemNaoAlterada != null 
                                        && pOrdemNaoAlterada.Quantidade.Value > ordemAlterar.Quantidade.Value) //NrqtdordA > Nrqtdord
                                    {
                                        bOrdemFin = true;
                                        //Call fStoreProcedureA()
                                        StoreProcedureA(ordemAlterar);
                                    }
                                    #endregion if17
                                }
                                #endregion if16

                                //If fIsAttribChanged('Cdbolsa') and -- Se bolsa da ordem foi modificada ( TORMOVD.CD_BOLSA ) e ( TipordF = 'S' or bEPop )
                                #region if18
                                if (pOrdemNaoAlterada != null 
                                    && !ordemAlterar.Bolsa.Equals(pOrdemNaoAlterada.Bolsa)
                                    //IsAttribChanged("Cdbolsa") 
                                    && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF == "S" 
                                        || bEPop
                                        )
                                    )
                                {
                                    //If CdbolsaA != Cdbolsa -- Se bolsa diferente da bolsa anterior à alteração
                                    #region if19
                                    if (pOrdemNaoAlterada != null 
                                        && !pOrdemNaoAlterada.Bolsa.Equals(ordemAlterar.Bolsa)) //CdbolsaA != Cdbolsa
                                    {
                                        //Set bOrdemFin = TRUE
                                        bOrdemFin = true;

                                        //If Not  AlteraBolsaFilhas ( )
                                        #region if20
                                        if (!AlteraBolsaFilhas(ordemAlterar))
                                        {
                                            throw new BusinessException(ERRO_ORDEM_ORDEMFINANCPOPFALHOUALTERACAOBOLSA); //"Ordens de financiamento/POP não puderam ser alteradas."
                                            //Return FALSE
                                        }
                                        else
                                        {
                                            //Call fStoreProcedureAF()
                                            StoreProcedureAF(ordemAlterar);
                                        }
                                        #endregion if20
                                    }
                                    #endregion if19
                                }
                                #endregion if18

                                //If fIsAttribChanged('Pcredacr') and -- Se modificou o percentual de acréscimo/redução ( TORMOVD.PC_REDACR ) e ( TipordF = 'S' or bEPop )
                                #region if21
                                if (pOrdemNaoAlterada != null 
                                    && pOrdemNaoAlterada.PercentualReducaoAcrescimo != ordemAlterar.PercentualReducaoAcrescimo //IsAttribChanged("Pcredacr") 
                                    && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF == "S" 
                                    || bEPop
                                        )
                                    )
                                {
                                    //If PcredacrA != Pcredacr -- Se percentual de acréscimo/redução diferente do percentual de acréscimo/redução anterior à alteração
                                    #region if22
                                    if (pOrdemNaoAlterada != null 
                                        && pOrdemNaoAlterada.PercentualReducaoAcrescimo != ordemAlterar.PercentualReducaoAcrescimo ) //PcredacrA != Pcredacr
                                    {
                                        //Set bOrdemFin = TRUE
                                        bOrdemFin = true;

                                        //Call fStoreProcedureC()
                                        StoreProcedureC(ordemAlterar);
                                    }
                                    #endregion if22
                                }
                                #endregion if21

                                //If fIsAttribChanged('Nrtipord') and -- Se modificou o tipo da ordem ( TORMOVD.TP_ORDEM ) e ( TipordF = 'S' or bEPop )
                                #region if23
                                if (pOrdemNaoAlterada != null 
                                    && !ListEnumTipoOrdemToInt(pOrdemNaoAlterada.TipoOrdem).Value.Equals(ListEnumTipoOrdemToInt(ordemAlterar.TipoOrdem)) //IsAttribChanged("Nrtipord") 
                                    && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)   //TipordF == "S" 
                                    || bEPop
                                        )
                                    )
                                {
                                    //If NrtipordA != Nrtipord  -- Se tipo da ordem diferente do tipo da ordem anterior à alteração
                                    #region if24
                                    if (pOrdemNaoAlterada != null 
                                        && !CompararTipoOrdem(pOrdemNaoAlterada.TipoOrdem,ordemAlterar.TipoOrdem)//IsAttribChanged("Nrtipord") //alterado para usar funcao de comparacao - eduardo sertorio - 200802271514
                                        )
                                    {
                                        //Call AlteraTipoOrdemFilhas( Nrtipord )
                                        AlteraTipoOrdemFilhas(ordemAlterar);

                                        //Set bOrdemFin = TRUE
                                        bOrdemFin = true;
                                    }
                                    #endregion if24
                                }
                                #endregion if23

                                //se Operador foi alterado
                                #region if24.5
                                if (pOrdemNaoAlterada.CodigoUsuarioOrdem.HasValue
                                    && pOrdemNaoAlterada.CodigoUsuarioOrdem.Value != ordemAlterar.CodigoUsuarioOrdem.Value //incluido - esertorio - 200805032130 - ref issue ID0003449
                                    && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF == "S" //incluido - esertorio - 200805062041 - ref issue ID0003449
                                        || bEPop //incluido - esertorio - 200805062041 - ref issue ID0003449
                                        )
                                    ) 
                                {
                                    if (!AlteraOutrosCamposFilhas(ordemAlterar)) //incluido - esertorio - 200805032130 - ref issue ID0003449
                                        throw new BusinessException(ERRO_ORDEM_ORDEMFINANCPOPFALHOUALTERACAOOUTROSCAMPOS); //incluido - esertorio - 200805032130 - ref issue ID0003449
                                }
                                #endregion if24.5

                                //Call fChangeNumberAttribute('CdUsuario', oAcesso.fGetUsuario() )
                                ordemAlterar.CodigoUsuarioConectado = Sinacor.Infra.Service.Security.Authorization.AuthorizationContext.Current.UserId; //corrigido de (CodigoUsuarioOrdem) para (CodigoUsuarioConectado) - esertorio - 200805021709 - ref issue ID0003449

                                //If cHstBsnObj.fUpdate() -- Efetua o update na TORMOVD dos atributos marcados como alterados
                                #region if25
                                if(Update(ordemAlterar))
                                {
                                    //If not  bOrdemFin
                                    #region if26
                                    if (!bOrdemFin)
                                    {
                                        //Call fVerQualChama()
                                        ExecutarStoredProcedureNecessaria(ordemAlterar);
                                    }
                                    #endregion if26

                                    //Call fAlteraAnt() //nao se aplica - 20080212 - eduardo
                                    //AlteraAnt(ordemAlterar); //nao se aplica - 20080212 - eduardo

                                    //Call fVeriSaldNgcv( fGetSqlHandle(), Cdcliente, Cdnegsp, Cdmercad, Cdnatope, Nrqtdord )
                                    VeriSaldNgcv(ordemAlterar);

                                    /// Data:08/02/2008 11:04
                                    /// Autor:CPimentel
                                    /// Obs: INCLUIDA NOVA CHAMADA DE INCLUSAO DE JUSTIFICATIVA
                                    /// 
                                    /// Data : 08/02/2008 11:04
                                    /// Autor: Eduardo Sertorio
                                    /// Obs. : Alterada local e forma de chamada do metodo
                                    IncluirJustificativaManutencaoOrdem(ordemAlterar);

                                    //Return TRUE
                                    return true;
                                }
                                else
                                {
                                    //Return FALSE
                                    return false;
                                }
                                #endregion if25

                            }
                            else
                            {
                                //Return FALSE
                                //return false;
                                if (this.validationException != null
                                    && this.validationException.ValidationErrors != null
                                    && this.validationException.ValidationErrors.Count > 0)
                                    throw this.validationException; //incluido - esertorio - 200804180941 - ref issue ID0003287
                                else
                                    return false; //mantido - 200804180941
                            }
                            #endregion if05
                        }
                        else
                        {
                            throw new BusinessException(ERRO_ORDEM_SEMPERMISSAOALTERARCOMVALIDADEPASSADA); //"Sem Permissão para Alterar Ordem com Validade anterior ao Movimento"
                            //Return FALSE
                        }
                        #endregion if04
                    }
                    else
                    {
                        //If ValidarTipoOrdem() and ....
                        #region if27
                        if (ValidarTipoOrdem(ordemAlterar)
                            && ValidarDataAte(ordemAlterar)
                            && ValidarOpcoes(ordemAlterar)
                            && ValidarVlprepap(ordemAlterar)
                            && ValidarCdcarliq(ordemAlterar)
                            && ValidarAltDeletados(ordemAlterar)
                            && ValidarLoteOpcao(ordemAlterar)
                            && ValidarNrqtdAnV(ordemAlterar)
                            && ValidarMega(ordemAlterar)
                            && PermiteAlteracaoAdminCon(ordemAlterar))
                        {
                            ////Set sTudo = sParte1||sParte2
                            //sTudo = sParte1 + sParte2; //nao se aplica - 20080128
                            ////Set nTudo = SalStrToNumber( sTudo )
                            //nTudo = Int32.Parse(sTudo); //nao se aplica - 20080128
                            //nao se aplica - 20080128
                            //Call fChangeNumberAttribute('Nrtipord', nTudo) -- Altera o atributo tipo da ordem ( TORMOVD.TP_ORDEM ) marcando-o como alterado

                            //Call fChangeStrAttribute('Intrigger', 'S') -- Altera o atributo de disparo da trigger de log ( TORMOVD.IN_TRIGGER ) marcando-o como alterado
                            ordemAlterar.IndicadorChamadaLog = true;

                            //If Nrqtdfec > 0
                            #region if28
                            if (ordemAlterar.QuantidadeCasada.HasValue && ordemAlterar.QuantidadeCasada.Value > 0) //Nrqtdfec > 0
                                bOrdemExe = true;
                            else
                                bOrdemExe = false;
                            #endregion if28

                            //If Alterou() 
                            #region if29
                            if (Alterou(ordemAlterar))
                            {
                                //If Insituac = 'E'
                                #region if30
                                if (ordemAlterar.Situacao.Equals("E")) //Insituac == "E"
                                {
                                    throw new BusinessException(ERRO_ORDEM_ORDEMEXERCICIOAUTOMATICONAOALTERAVEL); //"Ordem de exercício automático não pode ser alterada"
                                    //Return FALSE
                                }
                                else
                                {
                                    //Else If not fOrdemComValidadeAlteravel() and Dtdatord < Dtperval
                                    #region if31
                                    if (!OrdemComValidadeAlteravel(ordemAlterar)
                                        && ordemAlterar.DataOrdem < ordemAlterar.DataValidade //Dtdatord < Dtperval
                                       )
                                    {
                                        //Return FALSE
                                        return false;
                                    }
                                    else
                                    {
                                        //Else If ( fFinanciamento() and TipordF != 'S' ) and not bEPop
                                        #region if32
                                        if ((Financiamento() //testa internamente com OrdemNaoAlterada
                                                && !ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                                              ) && !bEPop
                                            )
                                        {
                                            //If Nrsubseq =  0
                                            #region if33
                                            if (ordemAlterar.NumeroOrdemSubSequencia.Equals(0)) //Nrsubseq == 0
                                            {
                                                //If fTemFilhas()
                                                #region if34
                                                if (TemFilhas(ordemAlterar))
                                                {
                                                    throw new BusinessException(ERRO_ORDEM_ORDEMFINANCIAMENTOPOPNAOALTERAVEL); //"Ordem de Financiamento ou POP não pode ser alterada - Exclua os detalhes!"
                                                    //Return FALSE
                                                }
                                                else
                                                {
                                                    //Call fChangeNumberAttribute('Nrqtdfec', 0)
                                                    ordemAlterar.QuantidadeCasada = 0;

                                                    //Call fChangeStrAttribute('Indistrib', 'N')
                                                    ordemAlterar.IndicadorDistribuicao = "N";
                                                }
                                                #endregion if34
                                            }
                                            else
                                            {
                                                //Call fChangeNumberAttribute('Nrqtdfec', 0)
                                                ordemAlterar.QuantidadeCasada = 0;

                                                //Call fChangeStrAttribute('Indistrib', 'N')
                                                ordemAlterar.IndicadorDistribuicao = "N";
                                            }
                                            #endregion if33
                                        }
                                        else
                                        {
                                            //Call fChangeNumberAttribute('Nrqtdfec', 0)
                                            ordemAlterar.QuantidadeCasada = 0;

                                            //Call fChangeStrAttribute('Indistrib', 'N')
                                            ordemAlterar.IndicadorDistribuicao = "N";
                                        }
                                        #endregion if32
                                    }
                                    #endregion if31
                                }
                                #endregion if30
                            }
                            #endregion if29

                            //If fIsAttribChanged('Cdcliente') and ( TipordF = 'S' or bEPop )
                            #region if35
                            if (pOrdemNaoAlterada != null 
                                && ordemAlterar.CodigoCliente != pOrdemNaoAlterada.CodigoCliente //IsAttribChanged("Cdcliente") 
                                && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF == "S" 
                                      || bEPop
                                      )
                                )
                            {
                                //If CdclienteA != Cdcliente 
                                if (pOrdemNaoAlterada != null 
                                    && ordemAlterar.CodigoCliente != pOrdemNaoAlterada.CodigoCliente) //CdclienteA != Cdcliente
                                {
                                    //Set bOrdemFin = TRUE
                                    bOrdemFin = true;

                                    //If Not AlteraClienteFilhas( )
                                    if (!AlteraClienteFilhas(ordemAlterar))
                                    {
                                        throw new BusinessException(ERRO_ORDEM_ORDEMFINANCPOPFALHOUALTERACAOCLIENTE); //"Ordens de financiamento/POP não puderam ser alteradas"
                                        //Return FALSE
                                    }
                                    else
                                    {
                                        //Call fStoreProcedureBF()
                                        StoreProcedureBF(ordemAlterar);
                                    }
                                }
                            }
                            #endregion if35

                            //If fIsAttribChanged('Nrqtdord') and ( TipordF = 'S' or bEPop )
                            #region if36
                            if (pOrdemNaoAlterada != null 
                                && ordemAlterar.Quantidade != pOrdemNaoAlterada.Quantidade //IsAttribChanged("Nrqtdord") 
                                && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF == "S" 
                                    || bEPop
                                    )
                                )
                            {
                                //If NrqtdordA >  Nrqtdord 
                                if (pOrdemNaoAlterada != null 
                                    && pOrdemNaoAlterada.Quantidade.Value > ordemAlterar.Quantidade.Value) //NrqtdordA > Nrqtdord
                                {
                                    //Set bOrdemFin = TRUE
                                    bOrdemFin = true;

                                    //Call fStoreProcedureA()
                                    StoreProcedureA(ordemAlterar);
                                }
                            }
                            #endregion if36

                            //If fIsAttribChanged('Cdbolsa') and bOrdemMae and ( TipordF = 'S' or bEPop )
                            #region if37
                            if (pOrdemNaoAlterada != null 
                                && ordemAlterar.Bolsa != pOrdemNaoAlterada.Bolsa  //IsAttribChanged("Cdbolsa") 
                                && bOrdemMae
                                && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF == "S" 
                                    || bEPop
                                    )
                               )
                            {
                                //If CdbolsaA != Cdbolsa
                                if (pOrdemNaoAlterada != null 
                                    && ordemAlterar.Bolsa != pOrdemNaoAlterada.Bolsa) //CdbolsaA != Cdbolsa
                                {
                                    //Set bOrdemFin = TRUE
                                    bOrdemFin = true;

                                    //If Not  AlteraBolsaFilhas ( )
                                    if (!AlteraBolsaFilhas(ordemAlterar))
                                    {
                                        throw new BusinessException(ERRO_ORDEM_ORDEMFINANCPOPFALHOUALTERACAOBOLSA); //"Ordens de financiamento/POP não puderam ser alteradas"
                                        //Return FALSE
                                    }
                                    else
                                    {
                                        //Call fStoreProcedureAF()
                                        StoreProcedureAF(ordemAlterar);
                                    }
                                }
                            }
                            #endregion if37

                            //If fIsAttribChanged('Pcredacr') and ( TipordF = 'S' or bEPop )
                            #region if38
                            if (pOrdemNaoAlterada != null 
                                && !ordemAlterar.PercentualReducaoAcrescimo.Value.Equals(pOrdemNaoAlterada.PercentualReducaoAcrescimo.Value) //IsAttribChanged("Pcredacr") 
                                && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF == "S" 
                                    || bEPop
                                    )
                                )
                            {
                                //If PcredacrA != Pcredacr 
                                if (pOrdemNaoAlterada != null 
                                    && ordemAlterar.PercentualReducaoAcrescimo != pOrdemNaoAlterada.PercentualReducaoAcrescimo) //PcredacrA != Pcredacr
                                {
                                    //Set bOrdemFin = TRUE
                                    bOrdemFin = true;

                                    //Call fStoreProcedureC()
                                    StoreProcedureC(ordemAlterar);
                                }
                            }
                            #endregion if38

                            //If fIsAttribChanged('Nrtipord') and ( TipordF = 'S' or bEPop )
                            #region if39
                            if (pOrdemNaoAlterada != null 
                                && !CompararTipoOrdem(ordemAlterar.TipoOrdem, pOrdemNaoAlterada.TipoOrdem)
                                && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF == "S" 
                                    || bEPop
                                    )
                                )
                            {
                                //If NrtipordA != Nrtipord 
                                if (pOrdemNaoAlterada != null 
                                    && !CompararTipoOrdem(ordemAlterar.TipoOrdem, pOrdemNaoAlterada.TipoOrdem))
                                {
                                    //Call AlteraTipoOrdemFilhas( Nrtipord )
                                    AlteraTipoOrdemFilhas(ordemAlterar);

                                    //Set bOrdemFin = TRUE
                                    bOrdemFin = true;
                                }
                            }
                            #endregion if39

                            //se Operador foi alterado
                            #region if39.5
                            if (pOrdemNaoAlterada.CodigoUsuarioOrdem.HasValue
                                && pOrdemNaoAlterada.CodigoUsuarioOrdem.Value != ordemAlterar.CodigoUsuarioOrdem.Value //incluido - esertorio - 200805032130 - ref issue ID0003449
                                && (ordemAlterar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento) //TipordF == "S" //incluido - esertorio - 200805062041 - ref issue ID0003449
                                    || bEPop //incluido - esertorio - 200805062041 - ref issue ID0003449
                                    )
                                )
                            {
                                if (!AlteraOutrosCamposFilhas(ordemAlterar))  //incluido - esertorio - 200805032130 - ref issue ID0003449
                                    throw new BusinessException(ERRO_ORDEM_ORDEMFINANCPOPFALHOUALTERACAOOUTROSCAMPOS); //incluido - esertorio - 200805032130 - ref issue ID0003449
                            }
                            #endregion if39.5

                            //Call fChangeNumberAttribute('CdUsuario', oAcesso.fGetUsuario() )
                            ordemAlterar.CodigoUsuarioConectado = Sinacor.Infra.Service.Security.Authorization.AuthorizationContext.Current.UserId;

                            //If cHstBsnObj.fUpdate()
                            #region if40
                            if (Update(ordemAlterar))
                            {
                                //If not  bOrdemFin
                                if (!bOrdemFin)
                                {
                                    //Call fVerQualChama()
                                    ExecutarStoredProcedureNecessaria(ordemAlterar);
                                }

                                //Call fAlteraAnt() //nao se aplica - 20080212 - eduardo
                                //AlteraAnt(ordemAlterar); //nao se aplica - 20080212 - eduardo

                                //Call fVeriSaldNgcv( fGetSqlHandle(), Cdcliente, Cdnegsp, Cdmercad, Cdnatope, Nrqtdord )
                                VeriSaldNgcv(ordemAlterar);

                                /// Data:08/02/2008 11:04
                                /// Autor:CPimentel
                                /// Obs: INCLUIDA NOVA CHAMADA DE INCLUSAO DE JUSTIFICATIVA
                                /// 
                                /// Data : 08/02/2008 11:04
                                /// Autor: Eduardo Sertorio
                                /// Obs. : Alterada local e forma de chamada do metodo
                                IncluirJustificativaManutencaoOrdem(ordemAlterar);

                                //Return TRUE
                                return true;
                            }
                            else
                            {
                                //Return FALSE
                                return false;
                            }
                            #endregion if40

                        }
                        else
                        {
                            if (this.validationException != null
                                && this.validationException.ValidationErrors != null
                                && this.validationException.ValidationErrors.Count > 0)
                                throw this.validationException; //incluido - esertorio - 200804180941 - ref issue ID0003287
                            else
                                return false; //mantido - 200804180941
                        }
                        #endregion if27
                    }
                    #endregion if03
                }
                else
                {
                    return false;
                }
                #endregion if02
            }
            else
            {
                //Return FALSE
                return false;
            }
            #endregion if01

        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data : 12/02/2008
        /// Obs. : Criacao do metodo para reaproveitar trecho de codigo
        /// </summary>
        /// <param name="request"></param>
        public void IncluirJustificativaManutencaoOrdem(BusinessEntity.Ordem request)
        {
            BusinessEntity.Justificativa reqJustificativa = new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Justificativa();
            reqJustificativa.Ordem = request;
            reqJustificativa.TextoJustificativa = request.TextoJustificativa;
            IncluirJustificativa(reqJustificativa);
        }

        /// <summary>
        /// Data:23/01/2008 14:15
        /// Autor:DMilanez.7Comm
        /// Obs:
        /// Metodo responsavel por comparar dos tipos de ordens (colecao)
        /// </summary>
        /// <param name="tipoOrdemA"></param>
        /// <param name="tipoOrdemB"></param>
        /// <returns></returns>
        private bool CompararTipoOrdem(List<Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem> tipoOrdemA, List<Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem> tipoOrdemB)
        {
            return (ListEnumTipoOrdemToInt(tipoOrdemA) ==
                    ListEnumTipoOrdemToInt(tipoOrdemB));
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 16/01/2008
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private BusinessEntity.Ordem ObterOrdemNaoAlterada(BusinessEntity.Ordem request)
        {
            return (new ResourceAccess.Ordem()).ConsultarOrdem(request);
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 17/01/2008
        /// </summary>
        /// <param name="request"></param>
        /// <returns>bool</returns>
        private bool Update(BusinessEntity.Ordem request) 
        {
            if (!request.HoraOrdem.HasValue)
                request.HoraOrdem = pOrdemNaoAlterada.HoraOrdem;

            int retorno = (new ResourceAccess.Ordem()).AlterarOrdem(request); //alterado - eduardo sertorio - 200702271837

            return retorno.Equals(1);
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 20/01/2008****
        /// </summary>
        /// <param name="request"></param>
        /// <returns>bool</returns>
        private bool Delete(BusinessEntity.Ordem request)
        {
            if (!request.CodigoUsuarioConectado.HasValue)
                request.CodigoUsuarioConectado = Sinacor.Infra.Service.Security.Authorization.AuthorizationContext.Current.UserId;

            return ((new ResourceAccess.Ordem()).CancelarOrdem(request)).Equals(1);
        }         

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 09/01/2008
        /// </summary>
        /// <param name="ordemValidar">BusinessEntity.Ordem</param>
        /// <returns>bool</returns>
        private bool ExisteFalhaNaRecepcao(BusinessEntity.Ordem ordemValidar)
        {
            //!
            //Set sCmd = "
            //        select count(*)
            //          into :nQtd
            //          from tordmega_e
            //         where nr_seqord = :Nrseqord
            //           and vl_erro not in ( 3, 9 )"
            //!
            //When SqlError
            //    Call SqlGetError( fGetSqlHandle(), nErro, sErro )
            //    Return TRUE
            //Call SqlPrepareAndExecute( fGetSqlHandle(), sCmd )
            //Call SqlFetchNext( fGetSqlHandle(), nRet )
            //!
            //If nErro != 0
            //    Call SalMessageBox( sErro, 'cObjTormovdMega.fExisteFalhaNaRecepcao', MB_Ok )
            //    Return TRUE
            //!

            BusinessEntity.OrdemMegaBolsa beOrdemMegaBolsaRequest = new BusinessEntity.OrdemMegaBolsa();

            beOrdemMegaBolsaRequest.DataOrdem = ordemValidar.DataOrdem;
            beOrdemMegaBolsaRequest.NumeroOrdem = ordemValidar.NumeroOrdem;
            beOrdemMegaBolsaRequest.NumeroOrdemSubSequencia = ordemValidar.NumeroOrdemSubSequencia;

            int count = (new Ordens.ResourceAccess.OrdemMegaBolsa()).ValidarRecepcao(beOrdemMegaBolsaRequest);

            //If nQtd > 0
            if (count > 0)
            {
                //    Call SalMessageBox( 'Existe pendência na recepção das ofertas para a ordem nº '||SalNumberToStrX( Nrseqord, 0 )||'.
                //            Verifique no menu "Ordens/Erros na Recepção de Ofertas Mega Bolsa e Negócios" a falha ocorrida e efetue a devida correção.', 'Atenção', MB_Ok | MB_IconStop )

                throw new BusinessException(ERRO_ORDEM_FALHANARECEPCAO); //"Existe pendência na recepção das ofertas para a ordem referenciada. Verifique no menu (Ordens/Erros na Recepção de Ofertas Mega Bolsa e Negócios) a falha ocorrida e efetue a devida correção."
            }
            //!
            //Return FALSE
            return false;
        }

        /// <summary>
        /// Verifica Acesso
        /// Autor: Eduardo Sertorio
        /// Data: 09/01/2008
        /// </summary>
        /// <param name="nomeGrupoAcesso"></param>
        /// <returns></returns>
        private static bool Acesso(string nomeGrupoAcesso)
        {
            return Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao(nomeGrupoAcesso);
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 09/01/2008
        /// </summary>
        /// <param name="ordemAlterar"></param>
        /// <returns>bool</returns>
        private bool ValidarAltDeletados(BusinessEntity.Ordem ordemAlterar)
        {
            //If Insituac = 'A' or  Insituac = 'S' or Insituac = 'H' or Insituac = 'D'
            if (ordemAlterar.Situacao.Equals("A")
                || ordemAlterar.Situacao.Equals("S")
                || ordemAlterar.Situacao.Equals("H")
                || ordemAlterar.Situacao.Equals("D"))
            {
                //    Return TRUE
                return true;
            }
            else
            {
                //Call fDisplayError( 'Ordens de Exercicio não podem ser alteradas, altere o negócio') -- Insituac = 'E'
                validationException.AddError(ERRO_ORDEM_ORDEMEXERCICIOAUTOMATICONAOALTERAVEL_02); //"Ordens de Exercicio não podem ser alteradas, altere o negócio."
                //Return FALSE
                return false;
            }
        }

        /// <summary>
        /// Data : 11/01/2008
        /// Autor: Eduardo Sertorio
        /// 
        /// Data : 02/04/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Alterado o metodo de comparação de Equals() para (!=) para evitar erro com valores nulos.
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns>bool</returns>
        private bool Alterou(BusinessEntity.Ordem ordemValidar)
        {
            /// Data:23/01/2008 14:20
            /// Autor:DMilanez.7Comm
            /// Obs: caso n tenha recuperado a ordem original da base, n faz as validacoes
            if (pOrdemNaoAlterada == null)
                return true;

            //If fIsAttribChanged('Cdmercad') -- Se atributo mercado alterado ( TORMOVD.CD_MERCAD )
            //    If CdmercadA != Cdmercad -- Se mercado diferente de mercado anterior à alteração
            if (pOrdemNaoAlterada.TipoMercado != ordemValidar.TipoMercado)
                //        Return TRUE
                return true;

            //If fIsAttribChanged('Nrqtdord') -- Se atributo quantidade da ordem alterado ( TORMOVD.QT_ORDEM )
            //    If NrqtdordA >  Nrqtdord
            if (pOrdemNaoAlterada.Quantidade != ordemValidar.Quantidade)
                //        Return TRUE
                return true;

            //If fIsAttribChanged('Cdnegsp') -- Se atributo Código de Negociação da ordem alterado ( TORMOVD.CD_NEGOCIO )
            //    If CdnegspA != Cdnegsp 
            if (pOrdemNaoAlterada.Titulo != ordemValidar.Titulo) //alterado - esertorio - 200804021600 - ref issue ID0002285
                //        Return TRUE
                return true;

            //If fIsAttribChanged('Cdnatope') -- Se atributo Natureza de Operação da ordem alterado ( TORMOVD.CD_NATOPE )
            //    If CdnatopeA != Cdnatope 
            if (pOrdemNaoAlterada.NaturezaOperacao != ordemValidar.NaturezaOperacao) //alterado - esertorio - 200804021600 - ref issue ID0002285
                //        Return TRUE
                return true;

            //If fIsAttribChanged('Vlprepap') -- Se atributo Preço da ordem alterado ( TORMOVD.VL_PREPAP )
            //    If VlprepapA != Vlprepap 
            if (pOrdemNaoAlterada.Preco != ordemValidar.Preco) //alterado - esertorio - 200804021600 - ref issue ID0002285
                //        Return TRUE
                return true;

            //If fIsAttribChanged('Cdcliente') -- Se atributo Código do cliente alterado ( TORMOVD.CD_CLIENTE )
            //    If CdclienteA != Cdcliente 
            if (pOrdemNaoAlterada.CodigoCliente != ordemValidar.CodigoCliente) //alterado - esertorio - 200804021600 - ref issue ID0002285
                //        Return TRUE
                return true;

            //If fIsAttribChanged('Pcredacr') -- Se atributo Percentual de Acréscimo/Redução alterado ( TORMOVD.PC_REDACR )
            //    If PcredacrA != Pcredacr
            if (pOrdemNaoAlterada.PercentualReducaoAcrescimo != ordemValidar.PercentualReducaoAcrescimo) //alterado - esertorio - 200804021600 - ref issue ID0002285
                //        Return TRUE
                return true;

            //If fIsAttribChanged('Cdbolsa') -- Se atributo Bolsa alterado ( TORMOVD.CD_BOLSA )
            //    If CdbolsaA != Cdbolsa
            if (pOrdemNaoAlterada.Bolsa != ordemValidar.Bolsa) //alterado - esertorio - 200804021600 - ref issue ID0002285
                //        Return TRUE
                return true;

            //If fIsAttribChanged('TpVctoTermo') -- Se atributo Vencimento do Termo alterado ( TORMOVD.TP_VCOTER )
            //    If TpVctoTermoA != TpVctoTermo
            if (pOrdemNaoAlterada.VencimentoTermo != ordemValidar.VencimentoTermo) //alterado - esertorio - 200804021600 - ref issue ID0002285
                //        Return TRUE
                return true;

            //If fIsAttribChanged('Cdcarliq') -- Se atributo Carteira alterado ( TORMOVD.CD_CARLIQ )
            //    If CdcarliqA != Cdcarliq
            if (pOrdemNaoAlterada.CodigoCarteira != ordemValidar.CodigoCarteira) //alterado - esertorio - 200804021824 - ref issue ID0002285
                //        Return TRUE
                return true;

            //If fIsAttribChanged('Inliquida') -- Se atributo Tipo de Liquidação alterado ( TORMOVD.IN_LIQUIDA )
            //    If InliquidaA != Inliquida
            if (pOrdemNaoAlterada.TipoLiquidacao != ordemValidar.TipoLiquidacao) //alterado - esertorio - 200804021600 - ref issue ID0002285
                //        Return TRUE
                return true;

            //If fIsAttribChanged('Nrtipord') -- Se atributo Tipo da Ordem alterado ( TORMOVD.TP_ORDEM )
            //    If NrtipordA  !=  Nrtipord
            if ( CompararTipoOrdem(pOrdemNaoAlterada.TipoOrdem, ordemValidar.TipoOrdem) )
            {
                if(
            //        If (NrtipordA = 3   AND ( Nrtipord = 34 or Nrtipord = 43 )) OR
                    (
                    pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Administrada)
                    && (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Administrada)
                        && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria)
                        )
                    )
            //                   (NrtipordA = 1   AND ( Nrtipord = 14 or Nrtipord = 41 )) OR
                    ||
                    (
                    pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Mercado)
                    && (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Mercado)
                        && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria)
                        )                     
                    )
                    ||
            //                   (NrtipordA = 6   AND ( Nrtipord = 46 or Nrtipord = 64 )) OR
                    (
                    pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                    && (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                        && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria)
                        )
                    )
                    ||
            //                   (NrtipordA = 5   AND ( Nrtipord = 45 or Nrtipord = 54 )) OR 
            //                  NrtipordA contem Limitada(5) e ( Nrtipord contem Limitada(4) e Discricionaria(5) ) //eduardo - 20080111
                    (
                    pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada)
                    && (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada)
                        && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria)
                        )
                    )
                    ||
                    (
            //                   (
            //                      ( NrtipordA = 36 or NrtipordA = 63 ) 
            //                      NrtipordA contem Administrada(3) e Financiamento(6) //eduardo - 20080111
                        (pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Administrada)
                        && pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                        )
            //                      AND ( Nrtipord = 46 or Nrtipord = 64 ) 
            //                      Nrtipord contem Discricionaria(4) e Financiamento(6) //eduardo - 20080111
                        &&
                        (ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria)
                        && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                        )
            //                   ) -- Se ligou/desligou tipo de ordem discricionária
                    )
                  )
                    //            Return FALSE -- No final só altera TORMOVD não precisando disparar processos de cálculo, descasamento ou casamento
                    return false;
                //        Else
                else
                    //            Return TRUE
                    return true;
            }

            //Return FALSE
            return false;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 11/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        private bool Financiamento() 
        { 
            //If NrtipordA = 6  
            //or NrtipordA = 16 
            //or NrtipordA = 26 
            //or NrtipordA = 36 
            //or NrtipordA = 46 
            //or NrtipordA = 56 
            //or NrtipordA = 61 
            //or NrtipordA = 62 
            //or NrtipordA = 63 
            //or NrtipordA = 64 
            //or NrtipordA = 65 
            //or NrtipordA = 67 
            //or NrtipordA = 76
            //    Return TRUE
            //Else
            //    Return FALSE
            return this.pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento); //Financiamento(6)
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 11/01/2008
        /// </summary>
        private bool AlteraBolsaFilhas(BusinessEntity.Ordem request) 
        { 
            //Return SqlPrepareAndExecute ( hSqlGeral, 
            //        "Update TORMOVD
            //        Set CD_BOLSA = :Cdbolsa,
            //            IN_TRIGGER = 'S',
            //            QT_ORDEXEC = 0
            //      Where NR_SEQORD = :Nrseqord
            //        and DT_DATORD = :Dtdatord
            //        and NR_SUBSEQ > 0" )
            int retorno = (new ResourceAccess.Ordem()).AlteraBolsaFilhas(request);
            return (retorno > 0); //alterado de (retorno.Equals(1)) para (retorno > 0) - esertorio - 200805030010 - ref issue ID0003996
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 11/01/2008
        /// </summary>
        private bool AlteraClienteFilhas(BusinessEntity.Ordem request)
        {
            //Update TORMOVD
            //   Set CD_CLIENTE = :Cdcliente,
            //       DV_CLIENTE = :Dvcliente,
            //       IN_TRIGGER = 'S',
            //       QT_ORDEXEC = 0
            // Where NR_SEQORD  = :Nrseqord
            //   and DT_DATORD  = :Dtdatord
            //   and NR_SUBSEQ <> :Nrsubseq" )
            int retorno = (new ResourceAccess.Ordem()).AlteraClienteFilhas(request);
            return (retorno > 0); //alterado de (retorno.Equals(1)) para (retorno > 0) - esertorio - 200804281629 - ref issue ID0003690
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 14/01/2008
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private bool AlteraTipoOrdemFilhas(BusinessEntity.Ordem request) 
        { 
            //Set sCmd = "
            //        Update TORMOVD
            //           set tp_ordem = :nTpOrdem
            //         Where NR_SEQORD = :Nrseqord
            //           and DT_DATORD = :Dtdatord
            //           and NR_SUBSEQ > 0"
            //!
            //If SqlPrepareAndExecute ( hSqlGeral, sCmd )
            //    Return TRUE
            //Else
            //    Return FALSE
            int retorno = (new ResourceAccess.Ordem()).AlteraTipoOrdemFilhas(request);
            return (retorno > 0); //alterado de (retorno.Equals(1)) para (retorno > 0) - esertorio - 200804281629 - ref issue ID0003690
        }

        /// <summary>
        /// Data : 03/05/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Criacao do metodo (AlteraOutrosCamposFilhas) - esertorio - 200805032136 - ref issue ID0003996 
        /// </summary>
        /// <param name="ordemAlterar"></param>
        /// <returns></returns>
        private bool AlteraOutrosCamposFilhas(BusinessEntity.Ordem ordemAlterar)
        {
            bool retorno = false;
            BusinessEntity.Ordem ordemFilhaFinPOP = new BusinessEntity.Ordem();

            ordemFilhaFinPOP.CodigoUsuarioOrdem = ordemAlterar.CodigoUsuarioOrdem;
            ordemFilhaFinPOP.DataOrdem = ordemAlterar.DataOrdem;
            ordemFilhaFinPOP.NumeroOrdem = ordemAlterar.NumeroOrdem;
            //nao atribui (NumeroOrdemSubSequencia) para que o update afete todas a ordem "mae/capa" e as "filhas" tambem.

            int linhasAfetadas = (new ResourceAccess.Ordem()).AlterarOrdemFinanciamentoPOP(ordemFilhaFinPOP);

            if (linhasAfetadas == -1)
                retorno = false; //nenhum campo foi enviado para alterar
            //else if (linhasAfetadas == 0) //excluido - esertorio - 200805081334 - ref issue ID0004504
            //    retorno = false; //nenhuma linha atualizada //excluido - esertorio - 200805081334 - ref issue ID0004504
            else if (linhasAfetadas >= 0) //alterado para aceitar zero quando nao tem filhas - esertorio - 200805081334 - ref issue ID0004504
                retorno = true; //atualizado com sucesso

            return retorno;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data : 14/01/2008
        /// Obs. : Criacao do metodo
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool ExecutarStoredProcedureNecessaria(BusinessEntity.Ordem ordemValidar)
        {
            //verifica campos alterados
            //chama StoredProcedureA
            #region if01
            if (
                //If (NrqtdordA    >  Nrqtdord) OR -- Se quantidade da ordem diferente da quantidade da ordem anterior à alteração ( TORMOVD.QT_ORDEM )
                ordemValidar.Quantidade != pOrdemNaoAlterada.Quantidade ||
                //   (CdmercadA    != Cdmercad) OR -- Se mercado diferente da mercado anterior à alteração ( TORMOVD.CD_MERCAD )
                ordemValidar.TipoMercado != pOrdemNaoAlterada.TipoMercado ||
                //   (CdnegspA     != Cdnegsp)  OR -- Se código de negociação diferente do código de negociação anterior à alteração ( TORMOVD.CD_NEGOCIO )
                ordemValidar.Titulo != pOrdemNaoAlterada.Titulo ||
                //   (CdnatopeA    != Cdnatope) OR -- Se natureza de operação diferente da natureza de operação anterior à alteração ( TORMOVD.CD_NATOPE )
                ordemValidar.NaturezaOperacao != pOrdemNaoAlterada.NaturezaOperacao ||
                //   (VlprepapA    != Vlprepap) OR -- Se preço diferente do preço anterior à alteração ( TORMOVD.VL_PREPAP )
                ordemValidar.Preco != pOrdemNaoAlterada.Preco ||
                //   (CdbolsaA     != Cdbolsa)  OR -- Se bolsa diferente da bolsa anterior à alteração ( TORMOVD.CD_BOLSA )
                ordemValidar.Bolsa != pOrdemNaoAlterada.Bolsa ||
                //   (TpVctoTermoA != TpVctoTermo) -- Se vencimento do termo diferente do vencimento do termo anterior à alteração ( TORMOVD.TP_VCOTER )
                ordemValidar.VencimentoTermo != pOrdemNaoAlterada.VencimentoTermo
            )
            {
                //    Call fStoreProcedureA()
                StoreProcedureA(ordemValidar);
            }
            #endregion if01

            //If NrtipordA !=  Nrtipord -- Se tipo da ordem diferente do tipo da ordem anterior à alteração ( TORMOVD.TP_ORDEM )
            //...
            //chama StoredProcedureA
            #region if02
            if (CompararTipoOrdem(pOrdemNaoAlterada.TipoOrdem,ordemValidar.TipoOrdem))
            {
                if (
                //    If (NrtipordA = 3    AND Nrtipord = 34) OR
                    ( pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Administrada)
                    && ( ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Administrada)
                        && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria)
                        )
                    )
                    ||
                //       (NrtipordA = 1    AND Nrtipord = 14) OR
                    ( pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Mercado)
                    && ( ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Mercado)
                        && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria)
                        )
                    )
                    ||
                //       (NrtipordA = 6    AND Nrtipord = 46) OR
                    ( pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                    && ( ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                        && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria)
                        )
                    )
                    ||
                //       (NrtipordA = 5    AND Nrtipord = 45) OR
                    ( pOrdemNaoAlterada.TipoOrdem.Contains( Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada)
                    && ( ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada)
                        && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Mercado)
                        )
                    )
                    ||
                //       (NrtipordA = 36  AND Nrtipord = 46) -- Se marcou/dismarcou o tipo discricionária
                    ( 
                        ( pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Administrada)
                        && pOrdemNaoAlterada.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                        )
                    &&  
                        ( ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Discricionaria)
                        && ordemValidar.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)
                        )
                    )                    
                 )
                {
                    //condicao vazia
                }
                //    Else
                else
                    //        Call fStoreProcedureA()
                    StoreProcedureA(ordemValidar);
            }
            #endregion if02

            //If (CdcarliqA  != Cdcarliq ) OR -- Se carteira diferente da carteira anterior à alteração ( TORMOVD.CD_CARLIQ )
            //...
            //chama StoredProcedureB
            #region if03
            if (!pOrdemNaoAlterada.CodigoCarteira.Value.Equals(ordemValidar.CodigoCarteira.Value)
            // (InliquidaA != Inliquida) -- Se tipo de liquidação diferente do tipo de liquidação anterior à alteração ( TORMOVD.IN_LIQUIDA )
                || !pOrdemNaoAlterada.TipoLiquidacao.Equals(ordemValidar.TipoLiquidacao))
            //    Call fStoreProcedureB()
                StoreProcedureB(ordemValidar);
            #endregion if03

            //If CdclienteA != Cdcliente  -- Se cliente diferente do cliente anterior à alteração ( TORMOVD.CD_CLIENTE )
            //chama StoredProcedureB
            #region if04
            if (!pOrdemNaoAlterada.CodigoCliente.Value.Equals(ordemValidar.CodigoCliente.Value))
            //    Call fStoreProcedureB()
                StoreProcedureB(ordemValidar);
            #endregion if04

            //If PcredacrA != Pcredacr -- Se atributo Percentual de Acréscimo/Redução alterado ( TORMOVD.PC_REDACR )
            //chama StoredProcedureC
            #region if05
            if (!pOrdemNaoAlterada.PercentualReducaoAcrescimo.Value.Equals(ordemValidar.PercentualReducaoAcrescimo.Value))
                //    Call fStoreProcedureC()
                StoreProcedureC(ordemValidar);
            #endregion if05

            //Return TRUE
            return true;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 16/01/2008
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public bool StoreProcedure(BusinessEntity.Ordem request) 
        {
            //"PR_CALFIN.FINANCEIRO_CLI( CdclienteA, sData,'cObjTormovd.fStoreProcedure')")
            ResumoFinanceiro.BusinessEntity.ResumoFinanceiro beResumoFinanceiro = new Sinacor.Servico.Bovespa.ResumoFinanceiro.BusinessEntity.ResumoFinanceiro();
            beResumoFinanceiro.DataMovimento = request.DataOrdem.Value;
            beResumoFinanceiro.IsCorrespondente = false; //tem que ser false para chamar FINANCEIRO_CLI
            beResumoFinanceiro.CodigoCliente = request.CodigoCliente.Value;
            (new ResumoFinanceiro.ResourceAccess.ResumoFinanceiro()).Calcular(beResumoFinanceiro);
            return true;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 14/01/2008
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public bool StoreProcedureA(BusinessEntity.Ordem request) 
        {
            //"PR_SINCRO.ATUA_DET_EXE(sData,Nrseqord,Nrsubseq,CdclienteA,CdbolsaA,'X')")
            (new ResourceAccess.Ordem()).StoreProcedureA(
                request.DataOrdem.Value, 
                request.NumeroOrdem.Value, 
                request.NumeroOrdemSubSequencia.Value, 
                request.CodigoCliente.Value, 
                request.Bolsa, 
                "X");

            return true;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 14/01/2008
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public bool StoreProcedureAF(BusinessEntity.Ordem request)
        {
            //"PR_SINCRO_F.ATUA_DET_EXE_F(sData,Nrseqord,Nrsubseq,CdclienteA,CdbolsaA)")
            (new ResourceAccess.Ordem()).StoreProcedureAF(
                request.DataOrdem.Value,
                request.NumeroOrdem.Value,
                request.NumeroOrdemSubSequencia.Value,
                request.CodigoCliente.Value,
                request.Bolsa);

            return true;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 14/01/2008
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public bool StoreProcedureB(BusinessEntity.Ordem request)
        {
			//"PR_SINCRO.ATUA_ALT_CLI(sData,Nrseqord,Nrsubseq,CdclienteA,CdbolsaA,'S')")
            (new ResourceAccess.OrdemMegaBolsa()).AtualizarAlteracaoCliente(
                request.DataOrdem.Value,
                request.NumeroOrdem.Value,
                request.NumeroOrdemSubSequencia.Value,
                request.CodigoCliente.Value,
                request.Bolsa, 
                "S");

            return true;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 14/01/2008
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public bool StoreProcedureBF(BusinessEntity.Ordem request)
        { 
            //'PR_SINCRO_F.ATUA_ALT_CLI_F(sData,Nrseqord,Nrsubseq,CdclienteA,CdbolsaA)')
            (new ResourceAccess.Ordem()).StoreProcedureBF(
                request.DataOrdem.Value, 
                request.NumeroOrdem.Value, 
                request.NumeroOrdemSubSequencia.Value, 
                request.CodigoCliente.Value, 
                request.Bolsa);

            return true;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 14/01/2008
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public bool StoreProcedureC(BusinessEntity.Ordem request) 
        { 
            //'PR_SINCRO.ATUA_ALT_REDACR(sData,Nrseqord,Nrsubseq,Cdcliente, CdbolsaA, Pcredacr)')
            (new ResourceAccess.OrdemMegaBolsa()).AtualizarAlteracaoPercentualReducaoAcrescimo(
                request.DataOrdem.Value,
                request.NumeroOrdem.Value,
                request.NumeroOrdemSubSequencia.Value,
                request.CodigoCliente.Value,
                request.Bolsa,
                request.PercentualReducaoAcrescimo.Value);

            return true;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 09/01/2008
        /// Nao Implementado - Nao Se Aplica A Esta Arquitetuta
        /// </summary>
        private static void AlteraAnt(BusinessEntity.Ordem ordemAlterar)
        {
            //Call fSetStrAttribute('CdmercadA', Cdmercad)
            //Call fSetNumberAttribute('NrqtdordA', Nrqtdord)
            //Call fSetStrAttribute('CdnegspA', Cdnegsp)
            //Call fSetStrAttribute('CdnatopeA', Cdnatope)
            //Call fSetNumberAttribute('VlprepapA', Vlprepap)
            //Call fSetNumberAttribute('CdclienteA', Cdcliente)
            //Call fSetStrAttribute('CdbolsaA', Cdbolsa)
            //Call fSetStrAttribute('InliquidaA', Inliquida)
            //Call fSetNumberAttribute('CdcarliqA', Cdcarliq)
            //Call fSetNumberAttribute('NrtipordA', Nrtipord)
            //Call fSetNumberAttribute('PcredacrA', Pcredacr)
            //Call fSetNumberAttribute('TpVctoTermoA', TpVctoTermo)
            //Return TRUE
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 11/01/2008
        /// </summary>
        /// <returns></returns>
        private bool PermiteAlteracaoAdminCon(BusinessEntity.Ordem ordemValidar) 
        { 
            //If InAdminCon != 'S' -- Se ordem não é Adminstrada Concorrente ( TORMOVD.IN_ADMIN_CON )
            if (!ordemValidar.IndicadorOrdemAbertaAdminCon.Value)
            {
                //    Return TRUE
                return true;
            }

            //!
            //Set sCmd = "
            //        select 0
            //          into :nNada
            //          from tormovd
            //         where in_situac    <> 'D'
            //           and dt_datord     = :Dtdatord
            //           and nr_subseq     = :Nrsubseq
            //           and nr_seqord_ori = :Nrseqord"
            //!
            //Call SqlPrepareAndExecute( fGetSqlHandle(), sCmd )
            //Call SqlFetchNext( fGetSqlHandle(), nRet )
            //!
            //If nRet = FETCH_EOF
            //    Return TRUE
            //!
            if ((new ResourceAccess.Ordem()).PermiteAlteracaoAdminCon(ordemValidar).Equals(0)) //nenhum registro encontrado
            {
                return true;
            }
            else
            {
                //Call fDisplayError( 'Ordem AdminCon possui distribuição. Para efetuar qualquer tipo de alteração nesta Ordem deve-se antes excluir a distribuição efetuada' )
                throw new BusinessException(ERRO_ORDEM_ORDEMDISTRIBUICAOADMINCONNAOALTERAVEL_02); //"Ordem AdminCon possui distribuição. Para efetuar qualquer tipo de alteração nesta Ordem deve-se antes excluir a distribuição efetuada."
            }

            //Return FALSE
            //return false;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 11/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns>bool</returns>
        private bool ValidarMega(BusinessEntity.Ordem ordemValidar)
        {
            //If LerMega() -- Se não é aberto pelo sinal Megabolsa / Retorna TRUE quando não é mega
            if (LerMega(ordemValidar))
            //    Return TRUE
                return true;

            //If fIsAttribChanged('Cdmercad') -- Mercado foi alterado ( o serviço fIsAttribChanged verifica se o atributo na classe foi marcado como alterado )
            //    If CdmercadA != Cdmercad  -- Se mercado diferente do mercado anterior à alteração
            if (pOrdemNaoAlterada != null
                && ordemValidar.TipoMercado != pOrdemNaoAlterada.TipoMercado)
            {
                //        Call fDisplayError ( 'Ordem aberta pelo Mega não pode alterar Mercado' )
                validationException.AddError(ERRO_ORDEM_ORDEMMEGANAOALTERAMERCADO); //"Ordem aberta pelo Mega não pode alterar Mercado."
                //        Return FALSE
                return false;
            }

            //If fIsAttribChanged('Nrqtdord') -- Quantidade da ordem foi alterada
            //    If NrqtdordA  !=  Nrqtdord -- Quantidade diferente da quantidade anterior à alteração
            if (pOrdemNaoAlterada != null
                && ordemValidar.Quantidade != pOrdemNaoAlterada.Quantidade)
            {
                //        Call fDisplayError ( 'Ordem aberta pelo Mega não pode alterar Quantidade' )
                validationException.AddError(ERRO_ORDEM_ORDEMMEGANAOALTERAQUANTIDADE); //"Ordem aberta pelo Mega não pode alterar Quantidade"
                //        Return FALSE
                return false;
            }

            //If fIsAttribChanged('Cdnegsp') -- Código de negociação foi alterado
            //    If CdnegspA != Cdnegsp -- Se código de negociação diferente do código de negociação anterior à alteração
            if (pOrdemNaoAlterada != null
                && ordemValidar.Titulo != pOrdemNaoAlterada.Titulo)
            {
                //        Call fDisplayError ( 'Ordem aberta pelo Mega não pode alterar Papel' )
                validationException.AddError(ERRO_ORDEM_ORDEMMEGANAOALTERATITULO); //"Ordem aberta pelo Mega não pode alterar Titulo"
                //        Return FALSE
                return false;
            }

            //If fIsAttribChanged('Cdnatope') -- Se natureza de operação foi alterada
            //    If CdnatopeA != Cdnatope -- Se natureza de operação diferente da natureza de operação anterior à alteração
            if (pOrdemNaoAlterada != null
                && ordemValidar.NaturezaOperacao != pOrdemNaoAlterada.NaturezaOperacao)
            {
                //        Call fDisplayError ( 'Ordem aberta pelo Mega não pode alterar Natureza' )
                validationException.AddError(ERRO_ORDEM_ORDEMMEGANAOALTERANATUREZA); //"Ordem aberta pelo Mega não pode alterar Natureza"
                //        Return FALSE
                return false;
            }

            //If fIsAttribChanged('Cdbolsa') -- Se bolsa foi alterada
            //    If CdbolsaA != Cdbolsa -- Se bolsa diferente da bolsa anterior à alteração
            if (pOrdemNaoAlterada != null
                && ordemValidar.Bolsa != pOrdemNaoAlterada.Bolsa) //corrigido operador logico de (==) para (!=) - esertorio - 200804180916 - ref issue ID0003287
            {
                //        Call fDisplayError ( 'Ordem aberta pelo Mega não pode alterar Bolsa' )
                validationException.AddError(ERRO_ORDEM_ORDEMMEGANAOALTERABOLSA); //"Ordem aberta pelo Mega não pode alterar Bolsa"
                //        Return FALSE
                return false;
            }

            //If fIsAttribChanged('Dtperval') -- Se data de validade alterada
            //    If DtpervalA != Dtperval -- Se data de validade diferente da data de validade anterior à alteração
            if (pOrdemNaoAlterada != null
                && ordemValidar.DataValidade != pOrdemNaoAlterada.DataValidade) //corrigido operador logico de (==) para (!=) - esertorio - 200804180903 - ref issue ID0003287
            {
                //        Call fDisplayError ( 'Ordem aberta pelo Mega não pode alterar Prazo de Validade' )
                validationException.AddError(ERRO_ORDEM_ORDEMMEGANAOALTERADATAVALIDADE); //"Ordem aberta pelo Mega não pode alterar Prazo de Validade"
                //        Return FALSE
                return false;
            }

            //Set sTudo = sParte1||sParte2 -- Atribuido pelo ValidarTipoOrdem
            //Set nTudo = SalStrToNumber( sTudo )
            int? nTudo = 0;
            //Int32.TryParse(sTudo, out nTudo);
            nTudo = ListEnumTipoOrdemToInt(ordemValidar.TipoOrdem);
            
            //int iTipoOrdemAux = 0;            
            //string sTipoOrdemAux1 = "";
            //string sTipoOrdemAux2 = "";
            //if (pOrdemNaoAlterada.TipoOrdem.Count >= 1)
            //    sTipoOrdemAux1 = pOrdemNaoAlterada.TipoOrdem[0].ToString();            
            //if (pOrdemNaoAlterada.TipoOrdem.Count >= 2)
            //    sTipoOrdemAux2 = pOrdemNaoAlterada.TipoOrdem[1].ToString();
            //Int32.TryParse(sTipoOrdemAux1 + sTipoOrdemAux2, out iTipoOrdemAux);
            //iTipoOrdemAux = Sinacor.Servico.Bovespa.BovespaBase.Service.Util.TipoOrdem.ListEnumTipoOrdemToInt(pOrdemNaoAlterada.TipoOrdem);

            int? NrtipordA = ListEnumTipoOrdemToInt(pOrdemNaoAlterada.TipoOrdem);

            //If NrtipordA !=  nTudo -- Se tipo da ordem diferente do tipo da ordem anterior a alteração
            if (NrtipordA != nTudo)
            {
                if (
                    //    If ( NrtipordA = 1 and ( nTudo = 14 or nTudo = 41 ) ) or
                        (NrtipordA == 1 && (nTudo == 14 || nTudo == 41)) ||
                    //               ( NrtipordA = 3 and ( nTudo = 34 or nTudo = 43 ) ) or
                        (NrtipordA == 3 && (nTudo == 34 || nTudo == 43)) ||

                //               ( NrtipordA = 5 and ( nTudo = 54 or nTudo = 45 ) ) or
                        (NrtipordA == 5 && (nTudo == 54 || nTudo == 45)) ||

                //               ( NrtipordA = 6 and ( nTudo = 64 or nTudo = 46 ) ) or
                        (NrtipordA == 6 && (nTudo == 64 || nTudo == 46)) ||

                //               ( ( NrtipordA = 36 or NrtipordA = 63 ) and ( nTudo = 64 or nTudo = 46 ) ) or
                        ((NrtipordA == 36 || NrtipordA == 63) && (nTudo == 64 || nTudo == 46)) ||

                //               ( ( NrtipordA = 64 or NrtipordA = 46 ) and ( nTudo = 36 or nTudo = 63 ) ) or
                        ((NrtipordA == 64 || NrtipordA == 46) && (nTudo == 36 || nTudo == 63)) ||

                //               ( ( NrtipordA = 64 or NrtipordA = 46 ) and nTudo = 6 ) or
                        ((NrtipordA == 64 || NrtipordA == 46) && nTudo == 6) ||

                //               ( ( NrtipordA = 54 or NrtipordA = 45 ) and nTudo = 5 ) or
                        ((NrtipordA == 54 || NrtipordA == 45) && nTudo == 5) ||

                //               ( ( NrtipordA = 34 or NrtipordA = 43 ) and nTudo = 3 ) or
                        ((NrtipordA == 34 || NrtipordA == 43) && nTudo == 3) ||

                //               ( ( NrtipordA = 14 or NrtipordA = 41 ) and nTudo = 1 ) -- Se apenas incluiu ou retirou o atributo de tipo de ordem discricionária ( tipo 4 )
                        ((NrtipordA == 14 || NrtipordA == 41) && nTudo == 1)
                )
                {
                    //condicao vazia conforme codigo Centura
                }
                //    Else
                else
                {
                    //        Call fDisplayError ( 'Ordem aberta pelo Mega não permite alteração do tipo da ordem' )
                    validationException.AddError(ERRO_ORDEM_ORDEMMEGANAOALTERATIPOORDEM); //"Ordem aberta pelo Mega não permite alteração do tipo da ordem."
                    //        Return FALSE
                    return false;
                }
            }

            //Return TRUE
            return true;
        }

        #endregion Manutencao de Ordens - Alterar

        #region Manutencao de Ordens - Excluir

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 11/01/2008
        /// </summary>
        /// <param name="ordemExcluir"></param>
        /// <returns></returns>
        public void ExcluirOrdem(BusinessEntity.Ordem ordemExcluir)
        {
            //executar
            ExecutarExcluirOrdem(ordemExcluir);            
        }

        ////////private bool Delete(BusinessEntity.Ordem ordemExcluir) [Cezar - 20090108]
        /// <summary>
        /// Autor: Cezar Pimentel
        /// Data: 08/01/2008
        /// Obs.: Codificacao
        /// 
        /// Autor: Eduardo Sertorio / Patricia Rosa
        /// Data: 17/01/2008
        /// Obs.: Revisao
        /// 
        /// Autor: Eduardo Sertorio
        /// Data : 27/02/2008
        /// Obs. : Incluida variavel (textoJustificativa) para manter e re-atribuir o texto da justificativa apos obter a ordem nao alterada.
        /// </summary>
        /// <param name="ordemExcluir"></param>
        /// <returns></returns>
        private bool ExecutarExcluirOrdem(BusinessEntity.Ordem ordemExcluir)
        {
            DateTime dDataMov;

            //verifica permissao para excluir ordem ("mãe", ou "capa" ou "principal")
            if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("EORD")) //incluir - eduardo sertorio - 200804241843 - ref issue ID0003474
            {
                throw new BusinessException(ERRO_ORDEM_SEMPERMISSAOEXCLUIRORDEM); //"Usuário sem permissão para excluir ordem."  //incluido - eduardo sertorio - 200804241843 - ref issue ID0003474
            }

            /// Data : 24/01/2008
            /// Autor:Eduardo Sertorio
            /// Metodo adicionado para realizar as validacoes de campos obrigatorios antes de alterar a ordem.
            ValidarObrigatoriosOrdem(ordemExcluir, "E");

            pOrdemNaoAlterada = this.ObterOrdemNaoAlterada(ordemExcluir);
            if(pOrdemNaoAlterada == null
                || (pOrdemNaoAlterada != null 
                    && pOrdemNaoAlterada.Situacao.Equals("D") //ja foi desativada - eduardo - 20080120****
                    )
               )
            {
                throw new BusinessException(ERRO_ORDEM_ORDEMINVALIDA); //"Ordem com chave inválida para alteracao/exclusao."
            }
            else
            {
                string textoJustificativa = ordemExcluir.TextoJustificativa; //incluido - eduardo sertorio - 200802271458
                ordemExcluir = pOrdemNaoAlterada;
                ordemExcluir.TextoJustificativa = textoJustificativa; //incluido - eduardo sertorio - 200802271458
            }

            //If NrSeqordOri != 0
            #region if01
            if (ordemExcluir.NumeroOrdemOriginal != 0)
            {
                //Call fDisplayError( 'Ordem gerada por distribuição de Ordem AdminCon não pode ser cancelada a não ser pelo cancelamento da distribuição da Ordem AdminCon de origem. Ordem AdminCon de origem possui nº '||SalNumberToStrX( NrSeqordOri, 0 ))
                throw new BusinessException(ERRO_ORDEM_ORDEMADMINCONNAOCANCELAVEL); //"Ordem gerada por distribuição de Ordem AdminCon não pode ser cancelada a não ser pelo cancelamento da distribuição da Ordem AdminCon de origem."
                //return;// false;
            }
            #endregion if01

            //Set bPauServidor = FALSE
            //Set NrqtdfecB = Nrqtdfec
            //Set InsituacA = Insituac
            
            //BuscaDataMovimento(ref dDataAtu, ref dDataMov);
            dDataMov = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();

            //If NOT LerMega()
            #region if02
            if (!LerMega(ordemExcluir))
            {
                throw new BusinessException(ERRO_ORDEM_ORDEMEGANAOCANCELAVEL); //"Ordem aberta pelo Mega não pode ser Excluida !"
                //return;// false;
            }
            #endregion if02

            //If dDataMov > Dtperval
            #region if03
            if (dDataMov > ordemExcluir.DataValidade)
            {
                //If oAcesso.fAcesso('D1SIM')
                #region if04
                if (Acesso("D1SIM"))
                {
                    //If Insituac = 'E'
                    #region if05
                    if (ordemExcluir.Situacao.Equals("E"))
                    {
                        throw new BusinessException(ERRO_ORDEM_EXERCICIOAUTOMATICONAOCANCELAVEL); //"Ordem de exercício automático não pode ser excluída"
                        //return;// false;
                    }
                    else
                    {
                        //Else If not fOrdemComValidadeAlteravel() and Dtdatord < Dtperval
                        #region if06
                        if (!OrdemComValidadeAlteravel(ordemExcluir) && (ordemExcluir.DataOrdem < ordemExcluir.DataValidade))
                        {
                            return true;// false;
                        }
                        #endregion if06
                    }
                    #endregion if05

                    //If Nrqtdfec > 0 -- Se Ordem executada
                    #region if07
                    if (ordemExcluir.QuantidadeCasada.Value > 0)
                    {
                        bOrdemExe = true;
                    }
                    else
                    {
                        bOrdemExe = false;
                    }
                    #endregion if07

                    //If TipordF  =  'S' -- Se Ordem do tipo Financiamento
                    #region if08
                    if (ordemExcluir.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)) //TipordF == "S"
                    {
                        //If Nrsubseq =  0 -- Se subsequência da ordem = 0
                        #region if09
                        if (ordemExcluir.NumeroOrdemSubSequencia.Equals(0))
                        {
                            //If fTemFilhas()
                            #region if10
                            if (TemFilhas(ordemExcluir))
                            {
                                throw new BusinessException(ERRO_ORDEM_ORDEMMAEFINANCIAMENTONAOCANCELAVEL); //"Ordem mãe de Financiamento não pode ser excluída"
                                //return;// false;
                            }
                            #endregion if10
                        }
                        #endregion if09
                    }
                    #endregion if08

                    //Insituac = "D";
                    ordemExcluir.Situacao = "D"; 

                    //Intrigger = "S";
                    ordemExcluir.IndicadorChamadaLog = true;

                    //Nrqtdfec = 0;
                    ordemExcluir.QuantidadeCasada = 0;

                    #region if11
                    if (ordemExcluir.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)) //TipordF == "S"
                    {
                        //Call fStoreProcedureA()
                        StoreProcedureA(ordemExcluir);
                    }
                    else
                    {
                        //Call fStoreProcedureA()
                        StoreProcedureA(ordemExcluir);
                    }
                    #endregion if11

                    //Call fChangeNumberAttribute('CdUsuario', oAcesso.fGetUsuario() )
                    ordemExcluir.CodigoUsuarioConectado = Sinacor.Infra.Service.Security.Authorization.AuthorizationContext.Current.UserId;

                    //If cHstBsnObj.fUpdate() -- Faz update na tormovd para os atributos marcados como alterado / semelhante Remoção de finpop.sql
                    #region if12
                    //if (Update(ordemExcluir))
                    if(Delete(ordemExcluir))
                    {
                        //If bOrdemExe -- Se ordem estava executada
                        #region if13
                        if (bOrdemExe)
                        {
                            //Call fStoreProcedure()
                            StoreProcedure(ordemExcluir);
                            //if (bPauServidor)
                            //{
                            //    return false;// false;
                            //}
                        }
                        #endregion if13

                        //Call fVeriSaldNgcv( fGetSqlHandle(), Cdcliente, Cdnegsp, Cdmercad, Cdnatope, Nrqtdord )
                        VeriSaldNgcv(ordemExcluir);

                        return true;// true;
                    }
                    else
                    {
                        return false;// false;
                    }
                    #endregion if12
                }
                else
                {
                    //Call fDisplayError ( 'Sem Permissão para Alterar Ordem com Validade anterior ao Movimento' )
                    throw new BusinessException(ERRO_ORDEM_SEMPERMISSAOEXCLUIRCOMVALIDADEPASSADA); //"Sem Permissão para Excluir ou Alterar Ordem com Validade anterior ao Movimento"
                    //Return FALSE //nao se aplica para BusinessException.
                }
                #endregion if04
            }
            else
            {
                //If Insituac = 'E'
                #region if14
                if (ordemExcluir.Situacao.Equals("E")) //Insituac == "E"
                {
                    throw new BusinessException(ERRO_ORDEM_EXERCICIOAUTOMATICONAOCANCELAVEL_02); //"Ordem de exercício automático não pode ser excluída"
                    //return;// false;
                }
                else
                {
                    //Else If not fOrdemComValidadeAlteravel() and Dtdatord < Dtperval
                    #region if15
                    if (!OrdemComValidadeAlteravel(ordemExcluir)
                    && (ordemExcluir.DataOrdem < ordemExcluir.DataValidade))
                    {
                        return false;// false;
                    }
                    #endregion if15
                }
                #endregion if14

                //If Nrqtdfec > 0
                #region if16
                if (ordemExcluir.QuantidadeCasada > 0)
                {
                    bOrdemExe = true;
                }
                else
                {
                    bOrdemExe = false;
                }
                #endregion if16

                //If TipordF  =  'S'
                #region if17
                if (ordemExcluir.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento))//TipordF == "S"
                {
                    //If Nrsubseq =  0
                    #region if18
                    if (ordemExcluir.NumeroOrdemSubSequencia == 0)
                    {
                        //If fTemFilhas()
                        #region if19
                        if (TemFilhas(ordemExcluir))
                        {
                            throw new BusinessException(ERRO_ORDEM_ORDEMMAEFINANCIAMENTONAOCANCELAVEL_02); //"Ordem mãe de Financiamento  não pode ser excluída"
                            //return;// false;
                        }
                        #endregion if19
                    }
                    #endregion if18
                }
                #endregion if17

                //Insituac = "D";
                ordemExcluir.Situacao = "D"; 

                //Intrigger = "S";
                ordemExcluir.IndicadorChamadaLog = true; 

                //Nrqtdfec = 0;
                ordemExcluir.QuantidadeCasada = 0;

                #region if20
                if (ordemExcluir.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento)) //TipordF == "S"
                {
                    //Call fStoreProcedureA()
                    StoreProcedureA(ordemExcluir);
                }
                else
                {
                    //Call fStoreProcedureA()
                    StoreProcedureA(ordemExcluir);
                }
                #endregion if20

                //if (bPauServidor)
                //{
                //    Nrqtdfec = NrqtdfecB;
                //    Insituac = InsituacA;
                //    return false;// false;
                //}

                //Call fChangeNumberAttribute('CdUsuario', oAcesso.fGetUsuario() )
                ordemExcluir.CodigoUsuarioConectado = Sinacor.Infra.Service.Security.Authorization.AuthorizationContext.Current.UserId;

                //If cHstBsnObj.fUpdate()
                #region if21
                //if (Update(ordemExcluir))
                if (Delete(ordemExcluir))
                {
                    //If bOrdemExe
                    #region if22
                    if (bOrdemExe)
                    {
                        //Call fStoreProcedure()
                        StoreProcedure(ordemExcluir);

                        //if (bPauServidor)
                        //{
                        //    return false;// false;
                        //}
                    }
                    #endregion if22

                    //Call fVeriSaldNgcv( fGetSqlHandle(), Cdcliente, Cdnegsp, Cdmercad, Cdnatope, Nrqtdord )
                    VeriSaldNgcv(ordemExcluir);

                    /// Data:08/02/2008 11:04
                    /// Autor:CPimentel
                    /// Obs: INCLUIDA NOVA CHAMADA DE INCLUSAO DE JUSTIFICATIVA
                    /// 
                    /// Data : 08/02/2008 11:04
                    /// Autor: Eduardo Sertorio
                    /// Obs. : Alterada local e forma de chamada do metodo
                    IncluirJustificativaManutencaoOrdem(ordemExcluir);

                    return true;
                }
                else
                {
                    return false;// false;
                }
                #endregion if21
            }
            #endregion if03

        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 11/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool LerMega(BusinessEntity.Ordem ordemValidar) 
        { 
            //Set sMega = 'N'
            //Call SqlPrepareAndExecute( hSqlGeral, "
            //        SELECT 'S'
            //          FROM TORDMEGA
            //         WHERE dt_datord = :Dtdatord
            //           and NR_SEQORD = :Nrseqord
            //           and nr_subseq = :Nrsubseq
            //          INTO :sMega") 
            //Call SqlFetchNext( hSqlGeral, nStatus)
            //If sMega = 'N'
            //    Return TRUE
            //Return FALSE
            Ordens.BusinessEntity.OrdemMegaBolsa beOrdemMegaBolsaRequest = new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.OrdemMegaBolsa();

            beOrdemMegaBolsaRequest.DataOrdem = ordemValidar.DataOrdem.Value;
            beOrdemMegaBolsaRequest.NumeroOrdem = ordemValidar.NumeroOrdem.Value;
            beOrdemMegaBolsaRequest.NumeroOrdemSubSequencia = ordemValidar.NumeroOrdemSubSequencia.Value;

            int count = (new Ordens.ResourceAccess.OrdemMegaBolsa()).ValidarMegaBolsa(beOrdemMegaBolsaRequest);

            return (count.Equals(0)); //deve retornar TRUE quando NAO FOR MEGA, isto é, count = 0
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 14/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private bool OrdemComValidadeAlteravel(BusinessEntity.Ordem ordemValidar)
        { 
            //Set sCmd = "
            //        select min(dt_mov)
            //          into :dtCal
            //          from tbocale
            //         where cd_praca = :Cdbolsa"
            //Call SqlPrepareAndExecute( fGetSqlHandle(), sCmd )
            //Call SqlFetchNext( fGetSqlHandle(), nRet )
            //If nRet = FETCH_Ok
            //    Set sCmd = "
            //            select min(dt_negocio)
            //              into :dtMov
            //              from torcomi
            //             where cd_bolsamov = :Cdbolsa
            //               and dt_datord   = :Dtdatord
            //               and nr_seqord   = :Nrseqord
            //               and nr_subseq   = :Nrsubseq"
            //    Call SqlPrepareAndExecute( fGetSqlHandle(), sCmd )
            //    Call SqlFetchNext( fGetSqlHandle(), nRet )

            DateTime? dtCal = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.Calendario()).RecuperarMenorDataMovimentoCalendarioPraca(ordemValidar.Bolsa);

            DateTime? dtMov = new ResumoFinanceiro.ResourceAccess.Comitente().RecuperarMenorDataNegocioComitente(
                ordemValidar.Bolsa,
                ordemValidar.DataOrdem.Value,
                ordemValidar.NumeroOrdem.Value,
                ordemValidar.NumeroOrdemSubSequencia.Value);

            //If nRet = FETCH_Ok // select min(dt_mov) into :dtCal
            if (dtCal.HasValue)
            {
            //    If dtMov != DATETIME_Null
                if (dtMov.HasValue)
                {
            //        If dtCal > dtMov
                    if (dtCal > dtMov)
                    {
            //            Call fDisplayError( 'Ordem com validade já casada fora do prazo para alteração de suas características e para exclusão.' )
                        throw new BusinessException(ERRO_ORDEM_ORDEMCASADAFORAVALIDADENAOCANCELAVEL); //"Ordem com validade já casada fora do prazo para alteração de suas características e para exclusão."
            //            Return FALSE
                    }
                }

            //    Return TRUE
                return true;
            }

            //Return FALSE
            return false;
        }

        /// <summary>
        /// Autor: Eduardo Sertorio
        /// Data: 11/01/2008
        /// </summary>
        /// <param name="ordemValidar"></param>
        /// <returns></returns>
        private static bool TemFilhas(BusinessEntity.Ordem ordemValidar) 
        { 
            //Call SqlPrepareAndExecute( hSqlGeral, "
            //        SELECT count(*)
            //          FROM TORMOVD 
            //         WHERE dt_datord = :Dtdatord
            //           and NR_SEQORD = :Nrseqord
            //           AND IN_SITUAC = 'A'
            //           AND NR_SUBSEQ > 0
            //          INTO :nQtd") 
            //Call SqlFetchNext( hSqlGeral, nStatus)
            //If nQtd > 0 
            //    Return TRUE
            //Else
            //    Return FALSE
            return (!((new ResourceAccess.Ordem()).VerificarExistenciaOrdensFilhas(ordemValidar)).Equals(0));
        }

        #endregion Manutencao de Ordens - Excluir

        #region Manutencao de Ordens - Consultar

        /// <summary>
        /// MEtodo responsavel por realizar a consulta de uma ordem
        /// Data: 20/12/2007
        /// Autor: Diogo Milanez
        /// Obs: Criacao do Metodo
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public BusinessEntity.Ordem ConsultarOrdem(BusinessEntity.Ordem request)
        {
            BusinessEntity.Ordem ordemBE;
            ResourceAccess.Ordem ordem = new ResourceAccess.Ordem();
            ordemBE = ordem.ConsultarOrdem(request);
            if (ordemBE == null)
            {
                ValidationException ex = new ValidationException();
                ex.AddError(ERRO_ORDEMINEXISTENTE);
                throw ex;
            }

            return ordemBE;
        }
       
        /// <summary>
        /// MEtodo responsavel por realizar a consulta de uma lista de ordens
        /// Data: 13/12/2007
        /// Autor: Diogo Milanez
        /// Obs: Criacao do Metodo
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
		public List<BusinessEntity.Ordem> ConsultarOrdens(BusinessEntity.Ordem filtroOrdens)
		{
            ValidarDataPregao(filtroOrdens.DataPregao);
            List<BusinessEntity.Ordem> retorno = (new ResourceAccess.Ordem()).ConsultarOrdens(filtroOrdens);
            if (retorno == null || retorno.Count == 0)
            {
				//throw new BusinessException(ERRO_PESQUISA_SEM_RESULTADO);
                retorno = new List<Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Ordem>();
            }
            return retorno;
		}


        /// <summary>
        /// Metodo responsavel por realizar a consulta de uma lista de ordens com dados de cliente
        /// Data: 20/01/2008
        /// Autor: Eduardo Sertorio
        /// Obs: Criacao do Metodo
        /// 
        /// Data : 07/03/2008
        /// Autor: Eduardo Sertorio / Ricardo Valadão
        /// Obs. : Alterado ValidationException por BusinessException para ERRO_PESQUISA_SEM_RESULTADO
        /// </summary>
        /// <param name="request"></param>
        /// <returns>List<BusinessEntity.Ordem></returns>
        public List<BusinessEntity.Ordem> ConsultarOrdensManutencaoOrdens(BusinessEntity.Ordem request)
        {
            if (!String.IsNullOrEmpty(request.ApelidoCliente))
            {
                request.Cliente = (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).ConsultarPorApelido(request.ApelidoCliente);
                if (request.Cliente != null) //incluido - esertorio - 200804112154 - ref issue ID0002878
                    request.CodigoCliente = request.Cliente.Codigo;
            }

            List<BusinessEntity.Ordem> response = (new ResourceAccess.Ordem()).ConsultarOrdensManutencaoOrdens(request,true);
            if (response == null)
            {
                //alterado ValidationException por BusinessException para ERRO_PESQUISA_SEM_RESULTADO - eduardo sertorio / ricardo valadao - 200803071704
                //ValidationException ex = new ValidationException();
                //ex.AddError(ERRO_PESQUISA_SEM_RESULTADO);
                //throw ex;
                throw new BusinessException(ERRO_PESQUISA_SEM_RESULTADO);
            }

            if (response != null)
            {
                foreach (BusinessEntity.Ordem itemOrdem in response)
                {
                    if (itemOrdem.CodigoCliente.HasValue && !itemOrdem.CodigoCliente.Value.Equals(0))
                    {
                        itemOrdem.Cliente = (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).ConsultarPorCodigo(itemOrdem.CodigoCliente.Value);
                        if (itemOrdem.Cliente != null) //incluido - esertorio - 200805082132 - ref issue ID0004612
                        {
                            itemOrdem.ApelidoCliente = itemOrdem.Cliente.Apelido;
                            itemOrdem.NomeCliente = itemOrdem.Cliente.Nome;
                        }
                    }
                }
            }

            return response;
        }

        public List<BusinessEntity.Ordem> ConsultarOrdensNegocio(BusinessEntity.Negocio negocio)
        {
            ValidarDataPregao(negocio.DataPregao);
            List<BusinessEntity.Ordem> retorno = (new ResourceAccess.Ordem()).ConsultarOrdensNegocio(negocio);
            if (retorno == null || retorno.Count == 0)
            {
                //throw new BusinessException(ERRO_PESQUISA_SEM_RESULTADO);
                retorno = new List<Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Ordem>();
            }
                return retorno;
        }

        private void ValidarDataPregao(DateTime? dataPregao)
        {
            if (dataPregao.HasValue)
                if ((new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.Calendario()).ValidarDataCalendario(dataPregao.Value) == false)
                {
                    throw new BusinessException(ERRO_CONSULTAORDENSNEGOCIOS_DATAPREGAOINVALIDA);
                }
        }
                
        //excluido - metodo nao utilizado - revisão - eduardo sertorio - 200803031537
        //private void Incluir(BusinessEntity.Ordem ordem)
        //{
        //    ResourceAccess.Ordem ordemDataAcess = new ResourceAccess.Ordem();
        //    ordemDataAcess.IncluirOrdem(ordem);
        //}

        #endregion Manutencao de Ordens - Consultar

        #region Diversos

        /// <summary>
		/// Metodo responsavel por recuperar o mercado de uma ordem
		/// </summary>
		/// <param name="numeroOrdem"></param>
		/// <returns></returns>
		public string RecuperarMercado(BusinessEntity.Ordem ordem)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			return ordemRA.ConsultarMercado(ordem);
		}

        /// <summary>
        /// Usado em BusinessLogic.PreBoleto.ValidarQuantidadeNegocio()
        /// Data: 28/11/2007
        /// Autor: Diogo Milanez
        /// </summary>
        /// <param name="ordem"></param>
        /// <returns></returns>
		public decimal RecuperarSaldo(BusinessEntity.Ordem ordem)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			return ordemRA.ConsultarSaldo(ordem);
		}

		/// <summary>
        /// Utilizado pelos servicos 
        /// [Ordens.ServiceImplementation.Ordem.DesprezarSaldoOrdem()] 
        /// e 
        /// [Ordens.ServiceImplementation.Ordem.ConsiderarSaldoOrdem()]
        /// Data:	22/11/2007
        /// Autor:	Diogo Milanez
        /// </summary>
		/// <param name="ordem"></param>
		/// <param name="desprezar"></param>
        public void DesprezarSaldo(BusinessEntity.Ordem ordem, bool desprezar)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			ordemRA.DesprezarSaldo(ordem, desprezar);
		}

		/// <summary>
		/// Metodo responsavel por verificar se a ordem ja foi distribuida
		/// </summary>
		/// <param name="ordem"></param>
		/// <returns></returns>
		public bool VerificarOrdemDistribuida(BusinessEntity.Ordem ordem, DateTime dataPregao)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			return ordemRA.VerificarOrdemDistribuida(ordem, dataPregao);
		}

		/// <summary>
		/// Metodo responsavel por incrementar o quantida de de uma ordem com o valor
		/// informado no objeto de parametro
		/// Historico:
		/// Data: 28/11/2007
		/// Autor: Diogo Milanez
		/// Observacoes: Criacao do metodo
		/// </summary>
		/// <param name="ordem"></param>
		public void IncrementarQuantidadeOrdem(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Ordem ordem)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			ordemRA.IncrementarQuantidadeOrdem(ordem);
			ordemRA = null;
		}

		/// <summary>
		/// Consulta Preco Limite da torPreco que pode ser executado 
		/// Historico:
		/// Data:	28/11/2007
		/// Autor:	Ludmilla Modesto
		/// Observacao: Criação do metodo
		/// </summary>
		/// <param name="desprezar"></param>
		public Decimal? ConsultarPrecoLimite(BusinessEntity.Ordem request)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			return ordemRA.ConsultarPrecoLimite(request);
		}

		/// <summary>
		/// Consulta Tipo de Ordem 
		/// Historico:
		/// Data:	28/11/2007
		/// Autor:	Ludmilla Modesto
		/// Observacao: Criação do metodo
		/// ******************************
		/// Data: 28/11/2007
		/// Autor: Diogo Milanez
		/// Observacao: Parametro de entrada foi alterado de Negocio para Ordem
		/// uma vez que a consulta é realizada com os dados da ordem
		/// Data: 29/11/2007
		/// Autor: Diogo Milanez
		/// Observacoes: Retorno passou a ser um tipo enumerado
		/// </summary>
		/// <param name="request"></param>
		/// <returns>Retorna o enum referente ao tipo da ordem, ou nulo no 
		/// caso do tipo de ordem nao poder ser mapeado para o enum</returns>
		public Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem? ConsultarTipoOrdem(BusinessEntity.Ordem request)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			string tipoOrdem = Convert.ToString(ordemRA.ConsultarTipoOrdem(request));
			if (tipoOrdem.Contains("5"))
				return Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Limitada;
			else if (tipoOrdem.Contains("7"))
				return Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.OnStop;
			else
				return null;

		}

		/// <summary>
		/// Retorne se existe ou Não Casamento
		/// Historico:
		/// Data:	28/11/2007
		/// Autor:	Ludmilla Modesto
		/// Observacao: Criação do metodo
		/// </summary>
		/// <param name="desprezar"></param>
		public Boolean VerificarExistenciaCasamento(BusinessEntity.Ordem request)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			return ordemRA.VerificarExistenciaCasamento(request);
		}

		/// <summary>
		/// Consulta tipo natureza operacao 
		/// Historico:
		/// Data:	28/11/2007
		/// Autor:	Ludmilla Modesto
		/// Observacao: Criação do metodo
		/// Data: 28/11/2007
		/// Autor: Diogo Milanez
		/// Observacao: Correcao no tipo de retorno
		/// </summary>
		/// <param name="desprezar"></param>
		public Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao? ConsultarNaturezaOperacao(BusinessEntity.Ordem request)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			return ordemRA.ConsultarNaturezaOperacao(request);
		}

		/// <summary>
        /// Utilizado por [Ordens.BusinessLogic.PreBoleto.RealizarAcoesPosCasamentoDescasamento()]
        /// Data: 07/12/2007
        /// Autor: Diogo Milanez
        /// </summary>
        /// <param name="ordem">BusinessEntity.Ordem</param>
        /// <returns>string</returns>
        public string VerificarCompliance(BusinessEntity.Ordem ordem)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			BusinessEntity.DadosVerificacaoCompliance dadosVerificacao = ordemRA.VerificarCompliance(ordem);

			if (dadosVerificacao.Total <= 0)
			{
				decimal saldo = dadosVerificacao.Total * -1;
				StringBuilder mensagem = new StringBuilder();

				if (dadosVerificacao.LimiteOperacional3 < saldo)
				{
					//Mensagem: Estourou o 3° limite operacional em :nSaldo - :nOpe3
					mensagem.Append("Estourou o 3° limite operacional em ");
					mensagem.AppendLine(Convert.ToString(saldo - dadosVerificacao.LimiteOperacional3));
				}
				else if (dadosVerificacao.LimiteOperacional2 < saldo)
				{
					//Mensagem: Estourou o 2° limite operacional em :nSaldo - :nOpe2
					mensagem.Append("Estourou o 2° limite operacional em ");
					mensagem.AppendLine(Convert.ToString(saldo - dadosVerificacao.LimiteOperacional2));
				}
				else if (dadosVerificacao.LimiteOperacional1 < saldo)
				{
					//Mensagem: Estourou o 1° limite operacional em :nSaldo - :nOpe1
					mensagem.Append("Estourou o 1° limite operacional em ");
					mensagem.AppendLine(Convert.ToString(saldo - dadosVerificacao.LimiteOperacional1));
				}

				mensagem.AppendLine(Convert.ToString(ordem.CodigoCliente) + ",");
				mensagem.AppendLine(Convert.ToString(dadosVerificacao.LimiteOperacional1) + ": 1º Limite operacional");
				mensagem.AppendLine(Convert.ToString(dadosVerificacao.LimiteOperacional2) + ": 2º Limite operacional");
				mensagem.AppendLine(Convert.ToString(dadosVerificacao.LimiteOperacional3) + ": 3º Limite operacional");
				mensagem.AppendLine(Convert.ToString(dadosVerificacao.OperacoesDia) + ": Operações do dia");
				mensagem.AppendLine(Convert.ToString(dadosVerificacao.SaldoContaCorrente) + ": Saldo em C/C");
				mensagem.AppendLine(Convert.ToString(saldo * -1) + ": Total");
				mensagem.AppendLine(dadosVerificacao.NomeCliente + ": Nome do Cliente");
				mensagem.AppendLine(dadosVerificacao.DddTelefone + ": DDD do telefone");
				mensagem.AppendLine(dadosVerificacao.NumeroTelefone + ": Número do telefone");
				mensagem.AppendLine(dadosVerificacao.NomeAssessor + ": Nome do assessor");

				return mensagem.ToString();
			}

			return null;
        }

        #endregion Diversos

		#region Financiamento POP

		#region Consultar Ordens Financiamento POP
		/// <summary>
		/// Metodo responsavel por realizar a consulta de sub-ordens de uma ordem
		/// Data: 11/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
        /// 
        /// Data : 28/02/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Revisao
        /// </summary>
		/// <param name="request"></param>
		/// <returns></returns>
		public List<BusinessEntity.Ordem> ConsultarSubOrdens(BusinessEntity.Ordem request)
		{
            ValidarConsultaSubOrdens(request);

            List<BusinessEntity.Ordem> response = (new ResourceAccess.Ordem()).ConsultarSubOrdens(request);

			return response;
		}
		/// <summary>
		/// Metodo responsavel por validar os dados de filtro informados para a consulta de
		/// sub-ordens de uma ordem (ordens com numeroSequencia > 0)
		/// Data: 11/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
        /// 
        /// Data : 28/02/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Validar DataOrdem e NumeroOrdem com valor nulo.
        /// </summary>
		/// <param name="request"></param>
		private void ValidarConsultaSubOrdens(BusinessEntity.Ordem request)
		{
			ValidationException ex = new ValidationException();

			if (String.IsNullOrEmpty(request.Situacao))
				ex.AddError(ERRO_ORDEMFINANCIAMENTOPOP_SITUACAONAOINFORMADA);

            //incluido - atributo pode aceitar nulo desde 04/01/2008 - eduardo sertorio - 200802271041
            if (!request.DataOrdem.HasValue)
                ex.AddError(ERRO_DATA_ORDEM_NAO_INFORMADA);
            else
            {
                if (request.DataOrdem == DateTime.MinValue)
                    ex.AddError(ERRO_ORDEMFINANCIAMENTOPOP_DATAORDEMINVALIDA);
            }

            //incluido - atributo pode aceitar nulo desde 04/01/2008 - eduardo sertorio - 200802271041
            if (!request.NumeroOrdem.HasValue)
                ex.AddError(ERRO_NUMERO_ORDEM_NAO_INFORMADO);
            else
            {
                if (request.NumeroOrdem <= 0)
                    ex.AddError(ERRO_ORDEMFINANCIAMENTOPOP_NUMEROORDEMINVALIDO);
            }

			if (ex.ValidationErrors != null && ex.ValidationErrors.Count > 0)
				throw ex;

		}
		#endregion

		#region Incluir Ordens Financiamento POP
		/// <summary>
		/// Metodo reponsavel por incluir ordens financiamento Pop
        /// 
        /// O casamento não esta sendo executado ao final da operacao devido a questoes
        /// de performance (pelo fato de salvar uma ordem por vez) isso foi validado com o analista sinacor (Nemir)
        /// 
		/// Data: 11/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
		/// 
		/// Data: 18/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Metodo foi renomeado de IncluirOrdensFinanciamentoPOP para IncluirOrdemFinanciamentoPOP
		/// </summary>
		/// <param name="request"></param>
		public BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP IncluirOrdemFinanciamentoPOP(BusinessEntity.Ordem ordemEntrada)
		{
			if (ordemEntrada == null) return null;

            string mensagemVerificacao;
			BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP retorno = null;
			BusinessLogic.PreBoleto preBoletoBL = new BusinessLogic.PreBoleto();
			Titulo.BusinessEntity.Titulo tituloBE;
			BusinessEntity.Ordem ordemBase = new BusinessEntity.Ordem();
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			Titulo.ResourceAccess.Titulo tituloRA = new Titulo.ResourceAccess.Titulo();
            DateTime now = (new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarDataSistemaBancoDados(); //DateTime.Now;

            ordemEntrada.NumeroOrdemSubSequencia = -1;
            ///validacoes de entrada de dados
            ValidarDadosEntradaOrdemFinanciamentoPOP(ordemEntrada);

			///recuperar a ordem
			ordemBase.DataOrdem = ordemEntrada.DataOrdem;
			ordemBase.NumeroOrdem = ordemEntrada.NumeroOrdem;
			ordemBase.NumeroOrdemSubSequencia = 0;
			ordemBase = ConsultarOrdem(ordemBase);

			///validar o tipo da ordem (Financiamento / POP)
			if (!VerificarOrdemFinanciamento(ordemBase) && !VerificarOrdemPOP(ordemBase))
				throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_TIPOESTRATEGIAINVALIDA);


			tituloBE = new Titulo.BusinessEntity.Titulo();
			tituloBE.DataOrdem = ordemBase.DataOrdem.Value;
			tituloBE.TipoMercado = (Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado) ordemEntrada.TipoMercado.Value;
			tituloBE.Codigo = ordemEntrada.Titulo;
			///recuperar o codigo isin do papel e a data de vencimento do termo
			tituloBE = tituloRA.ConsultarCodigoIsinDataVencimento(tituloBE);

			///caso n encontre o titulo q contem o codigo isin
			if (tituloBE == null)
				throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_TITULONAOENCONTRADO);

			ordemEntrada.Situacao = ordemBase.Situacao;
			ordemEntrada.Bolsa = ordemBase.Bolsa;
			ordemEntrada.DataOrdem = ordemBase.DataOrdem;
			ordemEntrada.NumeroOrdem = ordemBase.NumeroOrdem;

			///gerar a data/hora da ordem
            ordemEntrada.HoraOrdem = new DateTime(
                ordemEntrada.DataOrdem.Value.Year, 
                ordemEntrada.DataOrdem.Value.Month, 
                ordemEntrada.DataOrdem.Value.Day, 
                now.Hour, 
                now.Minute, 
                now.Second);


            //se nao informou a carteira
            if (!ordemEntrada.CodigoCarteira.HasValue) //incluido conforme explicacao Nemir - esertorio - 200804231830 - ref issue ID0003580
            {
                //se tipo da ordem é Financiamento
                if (ordemBase.TipoOrdem.Contains(TipoOrdem.Financiamento)) //incluido - conforme Nemir - 200804241040 - esertorio - ref issue ID0003580
                {
                    //se natureza da operação é Compra
                    if (ordemEntrada.NaturezaOperacao.Value.Equals(TipoNaturezaOperacao.Compra))
                    {
                        //se tipo do mercado é Vista
                        if (ordemEntrada.TipoMercado.Value.Equals(TipoMercado.Vista))
                        {
                            ordemEntrada.CodigoCarteira = 268; //incluido conforme explicacao Nemir - esertorio - 200804231830 - ref issue ID0003580
                        }
                    }
                    //se natureza da operação é Venda
                    else if (ordemEntrada.NaturezaOperacao.Value.Equals(TipoNaturezaOperacao.Venda))
                    {
                        //se tipo do mercado é Termo
                        if (ordemEntrada.TipoMercado.Value.Equals(TipoMercado.Termo))
                        {
                            if (!String.IsNullOrEmpty(ordemEntrada.Titulo))
                            {
                                //se termo é Flexível ("S")
                                if (ordemEntrada.Titulo.Substring(ordemEntrada.Titulo.Length - 1, 1).ToUpper().Equals("S")) //incluido - conforme Nemir - 200804241040 - esertorio - ref issue ID0003580
                                    ordemEntrada.CodigoCarteira = 0; //incluido - conforme Nemir - 200804241040 - esertorio - ref issue ID0003580
                            }
                        }
                    }
                }
                //se tipo da ordem é POP ?
                else if (ordemBase.CodigoISIN.Substring(6, 2).ToUpper().Equals("PP")) //incluido - conforme Nemir - 200804241040 - esertorio - ref issue ID0003580
                {
                    ordemEntrada.CodigoCarteira = 277; //incluido - conforme Nemir - 200804241040 - esertorio - ref issue ID0003580
                }

                //se ainda não determinou a carteira
                if (!ordemEntrada.CodigoCarteira.HasValue) //incluido - esertorio - 200804241907 - ref issue ID0003580
                {
                    BusinessEntity.MercadoCarteira mercadoCarteira = new BusinessEntity.MercadoCarteira();
                    mercadoCarteira.Bolsa = ordemEntrada.Bolsa;
                    mercadoCarteira.Carteira = null;
                    mercadoCarteira.Mercado.TipoMercado = ordemEntrada.TipoMercado.Value;
                    mercadoCarteira.NaturezaOperacao = ordemEntrada.NaturezaOperacao.Value;
                    mercadoCarteira.PrioridadeEscolhaCarteira = null;

                    //obtem  a carteira da tabela por prioridade
                    ordemEntrada.CodigoCarteira = (new ResourceAccess.Carteira()).ConsultarCarteiraComPrioridade(mercadoCarteira); //incluido - esertorio - 200804241907 - ref issue ID0003580
                }

                //se aiiiiinda não determinou a carteira
                if (!ordemEntrada.CodigoCarteira.HasValue) //incluido - esertorio - 200804241907 - ref issue ID0003580
                {
                    //exige digitação da carteira
                    throw new BusinessException(ERRO_ORDEM_CARTEIRANULO); //incluido - esertorio - 200804241907 - ref issue ID0003580
                }
            }
            
			ordemEntrada.TipoOrdem = ordemBase.TipoOrdem;
			ordemEntrada.CodigoCliente = ordemBase.CodigoCliente;
			ordemEntrada.DigitoCliente = ordemBase.DigitoCliente;
            //ordemEntrada.CodigoCarteira = ordemBase.CodigoCarteira; //excluido conforme Nemir - esertorio - 200804231819 - ref issue ID0003580
			ordemEntrada.IndicadorPessoaVinculada = ordemBase.IndicadorPessoaVinculada;
			ordemEntrada.TipoFax = ordemBase.TipoFax;
			ordemEntrada.PercentualReducaoAcrescimo = ordemBase.PercentualReducaoAcrescimo;
			ordemEntrada.QuantidadeCasada = 0;
			ordemEntrada.DataValidade = ordemBase.DataValidade;
			ordemEntrada.IndicadorDistribuicao = "N";
			ordemEntrada.CodigoUsuarioOrdem = ordemBase.CodigoUsuarioOrdem;
			ordemEntrada.NomeCliente = ordemBase.NomeCliente;
			ordemEntrada.ObservacaoOrdem = ordemBase.ObservacaoOrdem;
			ordemEntrada.IndicadorChamadaLog = false;
			ordemEntrada.TaxaFinanciamento = ordemBase.TaxaFinanciamento;
			ordemEntrada.ValorFinanciado = ordemBase.ValorFinanciado;
			ordemEntrada.IndicadorDesprezaSaldo = ordemBase.IndicadorDesprezaSaldo;
			ordemEntrada.NomeEmissorOrdem = ordemBase.NomeEmissorOrdem;
			ordemEntrada.QuantidadeAnexo4 = 0;
			ordemEntrada.QuantidadeAnexo5 = 0;
			ordemEntrada.CodigoISIN = tituloBE.CodigoISIN;
			ordemEntrada.Cambio = ordemBase.Cambio;
			ordemEntrada.TipoLiquidacao = ordemBase.TipoLiquidacao;
			ordemEntrada.ApelidoCliente = ordemBase.ApelidoCliente;
			ordemEntrada.IndicadorOrdemFilaCasamento = ordemBase.IndicadorOrdemFilaCasamento;
			ordemEntrada.CodigoUsuarioConectado = Sinacor.Infra.Service.Security.Authorization.AuthorizationContext.Current.UserId;
			ordemEntrada.QuantidadeCanceladaOferta = 0;
			ordemEntrada.IndicadorOrdemAbertaAdminCon = false;
			ordemEntrada.NumeroOrdemOriginal = 0;
            ordemEntrada.CodigoBroker = ordemBase.CodigoBroker; //incluido - esertorio - 200805032032 - ref issue ID0003996

			switch (ordemEntrada.TipoMercado)
			{
				case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo:
					if (VerificarTermoEmPontos(ordemEntrada))
                        ordemEntrada.CodigoCasamento = tituloBE.CodigoISIN + tituloBE.DataVencimentoTermo.Value.ToString("ddmmyyyy"); //corrigido (ordemBase) para (ordemEntrada) e vice-e-versa - esertorio - 200805041805 - ref issue ID0004255
					else
                        ordemEntrada.CodigoCasamento = tituloBE.CodigoISIN + ordemEntrada.VencimentoTermo.Value.ToString(); //corrigido - esertorio - 200805041805 - ref issue ID0004255
					break;
				case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra:
				case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda:
				case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Futuro:
				case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.VencimentoFuturo:
                    ordemEntrada.CodigoCasamento = tituloBE.CodigoISIN + ordemEntrada.Titulo; //corrigido (ordemBase) para (ordemEntrada) e vice-e-versa - esertorio - 200805041805 - ref issue ID0004255
					break;
				default:
                    ordemEntrada.CodigoCasamento = tituloBE.CodigoISIN; //corrigido (ordemBase) para (ordemEntrada) e vice-e-versa - esertorio - 200805041805 - ref issue ID0004255
					break;
			}

			///realizar as desvidas validacoes na ordem sendo incluida
			retorno = ValidarOrdemFinanciamentoPOP (ordemBase, ordemEntrada);

            ///verificar se ha saldo negociavel
            if (ordemEntrada.NaturezaOperacao.Value.Equals(TipoNaturezaOperacao.Venda) //incluido - esertorio - 200804241530 - ref issue ID0003580
                && (new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarIndicadorVerificacaoSaldoNegociavel().Equals("S")) //incluido - esertorio - 200804241530 - ref issue ID0003580
            {
                mensagemVerificacao = ordemRA.VerficarSaldoNegociavel(ordemEntrada);

                if (!String.IsNullOrEmpty(mensagemVerificacao))
                {
                    if (retorno == null)
                        retorno = new BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP();

                    retorno.MensagemVerificacaoSaldoNegociavel = new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.MensagemValidacao();
                    retorno.MensagemVerificacaoSaldoNegociavel.Codigo = 0;
                    retorno.MensagemVerificacaoSaldoNegociavel.Descricao = mensagemVerificacao;
                }
                else
                    retorno = null;
            }

			///caso a ordem esteja bloqueada nao permitir 
			if (retorno == null || retorno.VerificacaoBloqueio == null)
			{
                /// Data:22/01/2008 18:26
                /// Autor:DMilanez.7Comm
                /// Obs:
                /// Alterado de forma a gerar as chaves antes de solicitar a inclusao
                //ordemEntrada.NumeroOrdem = ordemRA.GerarNumero(ordemEntrada); //28/02/2008 - removido - dmilanez
                ordemEntrada.NumeroOrdemSubSequencia = ordemRA.ConsultarNumeroSubSequencia(ordemEntrada) + 1;

				if (ordemRA.IncluirOrdem(ordemEntrada) != 1)
					throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_ORDEMNAOINCLUIDA);
			}

			return retorno;
		}
		/// <summary>
		/// Se termo em pontos ( parte numérica do código de negociação possuir um número >= 50 )
		/// Metodo responsavel por verificar se um termo é em pontos
		/// Data: 12/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
		/// </summary>
		/// <param name="ordemBE"></param>
		/// <returns></returns>
		private bool VerificarTermoEmPontos(BusinessEntity.Ordem request)
		{
			if (String.IsNullOrEmpty(request.Titulo))
				return false;
			else
			{
				///recuperar a parte numerica do codigo de negociacao
				Regex r = new Regex(@"\d");
				string value = r.Match(request.Titulo).Value;
				if (string.IsNullOrEmpty(value))
					return false;
				else
				{
					if (Convert.ToInt32(value) >= 50)
						return true;
					else
						return false;
				}
			}
		}

        ///// <summary>
        ///// Metodo responsavel por realizar as validacoes de inclusao de ordens financiamento / pop
        ///// Data: 11/12/2007
        ///// Autor: Diogo Milanez
        ///// Obs: Criacao do metodo
        ///// </summary>
        ///// <param name="request"></param>
        //private BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP ValidarInclusaoOrdemFinanciamentoPOP(BusinessEntity.Ordem ordemBase,BusinessEntity.Ordem ordemEntrada)
        //{
        //    return ValidarOrdemFinanciamentoPOP(ordemBase,ordemEntrada);
        //}

		/// <summary>
		/// Metodo responsavel por verificar se ha algum bloqueio na ordem
		/// Data: 13/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
		/// </summary>
		/// <param name="request"></param>
		private BusinessEntity.RetornoVerificacaoBloqueio VerificarBloqueio(BusinessEntity.Ordem request)
		{
			BusinessEntity.RetornoVerificacaoBloqueio retorno = null;
			DateTime dataMovimento;
			Sinacor.Servico.Bovespa.Cliente.BusinessEntity.BloqueioCliente bloqueioClienteBE = new Sinacor.Servico.Bovespa.Cliente.BusinessEntity.BloqueioCliente();
			Sinacor.Servico.Bovespa.Cliente.BusinessLogic.Cliente clienteBL = new Sinacor.Servico.Bovespa.Cliente.BusinessLogic.Cliente();

			//Não pode existir bloqueio se ordem ativa ( semelhante ao utilizado na tela de Ordens via Megabolsa ):
			bloqueioClienteBE.CodigoCliente = request.CodigoCliente;
			bloqueioClienteBE.CodigoNegocio = request.Titulo;
			bloqueioClienteBE.NaturezaOperacao = (Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoNaturezaOperacao) request.NaturezaOperacao;
            bloqueioClienteBE.Mercado = (Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Enum.TipoMercado) request.TipoMercado;

			dataMovimento = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();

			if (request.DataValidade < dataMovimento)
				bloqueioClienteBE.DataPregao = request.DataValidade;
			else
				bloqueioClienteBE.DataPregao = dataMovimento;

			bloqueioClienteBE = clienteBL.VerificarBloqueioCliente(bloqueioClienteBE);

			if (bloqueioClienteBE != null && bloqueioClienteBE.isBloqueado)
			{
				retorno = new BusinessEntity.RetornoVerificacaoBloqueio();
				retorno.Mensagem.Descricao = bloqueioClienteBE.DescricaoBloqueio;

				switch (bloqueioClienteBE.TipoBloqueio)
				{
					case "A":
						retorno.TipoBloqueio = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoBloqueio.Assessor;
						break;
					case "C":
						retorno.TipoBloqueio = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoBloqueio.Cliente;
						break;
					case "G":
						retorno.TipoBloqueio = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoBloqueio.GrupoAfinidade;
						break;
					case "M":
						retorno.TipoBloqueio = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoBloqueio.Mercado;
						break;
					case "P":
						retorno.TipoBloqueio = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoBloqueio.Papel;
						break;
					case "T":
						retorno.TipoBloqueio = Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoBloqueio.TipoCliente;
						break;
				}
			}

			return retorno;
		}

		/// <summary>
		/// Metodo responsavel por validar a quantidade de ordens financiamento e POP
		/// Data: 13/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
		/// </summary>
		/// <param name="request"></param>
		private void ValidarQuantidadeOrdemFinanciamentoPOP(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Ordem request)
		{
			decimal? quantidadeMininaLote;
			Titulo.BusinessLogic.Titulo tituloBL = new Titulo.BusinessLogic.Titulo();
			Titulo.BusinessEntity.Titulo tituloBE = new Titulo.BusinessEntity.Titulo();

			switch (request.TipoMercado)
			{
				case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra:
				case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda:
					tituloBE.DataPregao = request.DataPregao.Value;
					tituloBE.Codigo = request.Titulo;
					quantidadeMininaLote = tituloBL.ConsultarQuantidadeMinimaLoteNegociacao(tituloBE);
					if (quantidadeMininaLote > 0)
					{
						if (request.Quantidade % quantidadeMininaLote != 0)
							throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_QUANTIDADEINVALIDA);
					}
					break;
				default:
					if (request.Quantidade <= 0)
						throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_QUANTIDADEINVALIDA);
					break;
			}
		}

		/// <summary>
		/// Metodo responsavel por validar o preco do papel para ordem financiamento e POP
		/// Data: 13/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
		/// </summary>
		/// <param name="request"></param>
		private void ValidarPrecoPapelOrdemFinancimentoPOP(BusinessEntity.Ordem request)
		{
			if (!request.Preco.HasValue)
				throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_PRECOINVALIDO);
			else if (request.Preco <= 0)
				throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_PRECOINVALIDO);
		}

		/// <summary>
		/// Metodo responsavel por validar o vencimento do termo para ordens financimento
		/// Data: 13/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
		/// </summary>
		/// <param name="request"></param>
		private void ValidarVencimentoTermoOrdemFinanciamentoPOP(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Ordem request)
		{
			if (VerificarOrdemFinanciamento(request))
			{
				if (request.TipoMercado == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo)
				{
					if (VerificarTermoEmPontos(request))
					{
						request.VencimentoTermo = null;
					}
					else if (request.VencimentoTermo <= 0)
					{
						throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_VENCIMENTOTERMOINVALIDO);
					}
				}
				else
				{
					request.VencimentoTermo = null;
				}
			}
			else if (VerificarOrdemPOP(request))
			{
				request.VencimentoTermo = null;
			}
		}

        /// <summary>
        /// Metodo responsavel por consultar a carteira padrao de uma ordem financiamento/POP
        /// Data: 04/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Criacao do metodo
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public int? ConsultarCarteiraPadrao(BusinessEntity.Ordem request)
        {
            int? codigoCarteira=0;
            BusinessEntity.Ordem ordemBase;
            Titulo.BusinessEntity.Titulo tituloBE;
            Titulo.ResourceAccess.Titulo tituloRA = new Sinacor.Servico.Bovespa.Titulo.ResourceAccess.Titulo();
            ResourceAccess.Ordem ordemRA = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();
            ResourceAccess.Carteira carteiraRA = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Carteira();
            BusinessEntity.MercadoCarteira mercadoCarteiraBE = new BusinessEntity.MercadoCarteira();

            ordemBase = ordemRA.ConsultarOrdem(request);
            if (ordemBase == null)
                return null;

            tituloBE = new Titulo.BusinessEntity.Titulo();
            tituloBE.DataOrdem = request.DataOrdem.Value;
            tituloBE.TipoMercado = (Sinacor.Servico.Bovespa.Titulo.BusinessEntity.Enum.TipoMercado) request.TipoMercado.Value;
            tituloBE.Codigo = request.Titulo;
            ///recuperar o codigo isin do papel e a data de vencimento do termo
            tituloBE = tituloRA.ConsultarCodigoIsinDataVencimento(tituloBE);

            ///caso n encontre o titulo q contem o codigo isin
            if (tituloBE == null)
                throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_TITULONAOENCONTRADO);

            request.CodigoISIN = tituloBE.CodigoISIN;

            if (VerificarOrdemPOP(ordemBase))
            {
                ///assumir a carteira defaul para ordens pop
                return 277;
            }
            else if (VerificarOrdemFinanciamento(ordemBase))
            {
                mercadoCarteiraBE.Bolsa = request.Bolsa;
                mercadoCarteiraBE.Mercado.TipoMercado = request.TipoMercado.Value;
                mercadoCarteiraBE.NaturezaOperacao = request.NaturezaOperacao.Value;

                ///validar carteira e mercado (VIS ou TER)
                switch (request.TipoMercado)
                {
                    case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo:
                        if (request.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Compra)
                        {
                            //Buscar carteira com prioridade
                            codigoCarteira = carteiraRA.ConsultarCarteiraComPrioridade(mercadoCarteiraBE);
                            if (!codigoCarteira.HasValue)
                                throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_CARTEIRAPRIORITARIANAOENCONTRADA);
                            else
                                return codigoCarteira;
                        }
                        else if (request.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Venda)
                        {
                            if (VerificarTermoFlexivel(request))
                                return 0;
                            else
                            {
                                //Buscar carteira com prioridade
                                codigoCarteira = carteiraRA.ConsultarCarteiraComPrioridade(mercadoCarteiraBE);
                                if (!codigoCarteira.HasValue)
                                    throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_CARTEIRAPRIORITARIANAOENCONTRADA);
                            }
                        }
                        else
                            return null;

                        break;
                    case Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista:
                        if (request.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Compra)
                            return 268;
                        else if (request.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Venda)
                        {
                            //Buscar carteira com prioridade
                            codigoCarteira = carteiraRA.ConsultarCarteiraComPrioridade(mercadoCarteiraBE);
                            if (!codigoCarteira.HasValue)
                                throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_CARTEIRAPRIORITARIANAOENCONTRADA);
                            else
                                return codigoCarteira;
                        }
                        else
                            return null;

                    default:
                        return null;
                }
            }            

            return null;
        }

        private void ValidarCarteiraOrdemFinanciamentoPOP(BusinessEntity.Ordem ordemEntrada)
        {
            ResourceAccess.Carteira carteiraRA = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Carteira();
            BusinessEntity.MercadoCarteira mercadoCarteiraBE = new BusinessEntity.MercadoCarteira();
            mercadoCarteiraBE.Bolsa = ordemEntrada.Bolsa;
            mercadoCarteiraBE.Mercado.TipoMercado = ordemEntrada.TipoMercado.Value;
            mercadoCarteiraBE.NaturezaOperacao = ordemEntrada.NaturezaOperacao.Value;
            mercadoCarteiraBE.Carteira.CodigoCarteira = ordemEntrada.CodigoCarteira.Value;
            if (!carteiraRA.VerificarExistenciaCarteira(mercadoCarteiraBE))
                throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_CARTEIRANAOCADASTRADA);
        }

		private void ValidarMercadoOrdemFinanciamentoPOP(BusinessEntity.Ordem ordemBase,BusinessEntity.Ordem ordemEntrada)
		{
			ResourceAccess.Carteira carteiraRA = new ResourceAccess.Carteira();
			BusinessEntity.Mercado mercadoBE = new BusinessEntity.Mercado();
			ResourceAccess.Mercado mercadoRA = new ResourceAccess.Mercado();

			///verificar a existencia do mercado na base de dados
			mercadoBE.TipoMercado = ordemEntrada.TipoMercado.Value;
			if (!mercadoRA.VerificarExistenciaMercado(mercadoBE))
				throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_TIPOMERCADOINVALIDO);
         

			if (VerificarOrdemPOP(ordemEntrada))
			{
				//Para ordens POP o mercado é atrelado à Natureza de Operação:
				//Se a ordem chamadora ( subsequência 0 ) for de Compra, só aceitar:
				if (ordemBase.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Compra)
				{
					if (ordemEntrada.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Compra )
					{
						//mercado deve ser Vista ou Opcao Venda
						if (ordemEntrada.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista &&
   					 		ordemEntrada.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda								
						   )
							throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_TIPOMERCADOINVALIDO);
					}
					else if (ordemEntrada.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Venda)
					{
						///mercado deve ser Opcao Compra
						if (ordemEntrada.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra)
							throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_TIPOMERCADOINVALIDO);
					}
				}
				else if (ordemBase.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Venda)
				{
					if (ordemEntrada.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Venda)
					{
						//mercado deve ser Vista ou Opcao Venda
						if (ordemEntrada.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista &&
							ordemEntrada.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoVenda
						   )
							throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_TIPOMERCADOINVALIDO);
					}
					else if (ordemEntrada.NaturezaOperacao == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoNaturezaOperacao.Compra)
					{
						///mercado deve ser Opcao Compra
						if (ordemEntrada.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.OpcaoCompra)
							throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_TIPOMERCADOINVALIDO);
					}
				}
			}
			else if (VerificarOrdemFinanciamento(ordemEntrada))
			{
                ///validar o mercado
                if (ordemEntrada.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Termo &&
                    ordemEntrada.TipoMercado != Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoMercado.Vista)                    
                    throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_NATUREZAOPERACAOINVALIDA);
			}
		}

		/// <summary>
		/// Metodo responsavel por verificar se um termo e flexivel
		/// Data: 13/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criadao do metodo
		/// </summary>
		/// <param name="request"></param>
		/// <returns></returns>
		private bool VerificarTermoFlexivel(BusinessEntity.Ordem request)
		{
			///Se Termo Flexível ( Código de Negociação acaba com o caracter 'S' )
			if (String.IsNullOrEmpty(request.Titulo))
				return false;
			else if (request.Titulo.Contains("S"))
				return true;
			else
				return false;

		}

		#endregion

		#region Alterar Ordens Financiamento POP

        #region REMOVIDO SEGUNDO ORIENTACAO DO ANALISTA SINACOR (KLEBER)
        ////REMOVIDO SEGUNDO ORIENTACAO DO ANALISTA SINACOR (KLEBER)
        ///// <summary>
        ///// Alterar ordens financiamento Pop
        ///// 
        ///// O casamento não esta sendo executado ao final da operacao devido a questoes
        ///// de performance (pelo fato de salvar uma ordem por vez) isso foi validado com o analista sinacor (Nemir)
        /////
        ///// Data: 11/12/2007
        ///// Autor: Diogo Milanez
        ///// Obs: Criacao do metodo
        ///// 
        ///// Data: 19/12/2007
        ///// Autor: Diogo Milanez
        ///// Metodo foi renomeado de AlterarOrdensFinanciamentoPOP para AlterarOrdemFinanciamentoPOP
        ///// </summary>
        ///// <param name="request"></param>
        //public BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP AlterarOrdemFinanciamentoPOP(BusinessEntity.Ordem ordemEntrada)
        //{
        //    if (ordemEntrada == null) return null;

        //    string mensagemVerificacao;
        //    BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP retorno = null;
        //    BusinessLogic.PreBoleto preBoletoBL = new BusinessLogic.PreBoleto();
        //    Titulo.BusinessEntity.Titulo tituloBE;
        //    BusinessEntity.Ordem ordemOriginal = new BusinessEntity.Ordem();
        //    BusinessEntity.Ordem ordemBase = new BusinessEntity.Ordem();
        //    ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
        //    Titulo.ResourceAccess.Titulo tituloRA = new Titulo.ResourceAccess.Titulo();
        //    DateTime now = DateTime.Now;

        //    ///validacoes de entrada de dados
        //    ValidarDadosEntradaOrdemFinanciamentoPOP(ordemEntrada);
            
        //    ///recuperar a ordem original
        //    ordemOriginal.DataOrdem = ordemEntrada.DataOrdem;
        //    ordemOriginal.NumeroOrdem = ordemEntrada.NumeroOrdem;
        //    ordemOriginal.NumeroOrdemSubSequencia = ordemEntrada.NumeroOrdemSubSequencia;
        //    ordemOriginal = ConsultarOrdem(ordemOriginal);

        //    ///recuperar a ordem base (sub-sequencia == 0)
        //    ordemBase.DataOrdem = ordemEntrada.DataOrdem;
        //    ordemBase.NumeroOrdem = ordemEntrada.NumeroOrdem;
        //    ordemBase.NumeroOrdemSubSequencia = 0;
        //    ordemBase = ConsultarOrdem(ordemBase);

        //    ///validar o tipo da ordem (Financiamento / POP)
        //    if (!VerificarOrdemFinanciamento(ordemBase) && !VerificarOrdemPOP(ordemBase))
        //        throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_TIPOESTRATEGIAINVALIDA);


        //    ///recuperar o codigo isin do papel e a data de vencimento do termo
        //    tituloBE = new Titulo.BusinessEntity.Titulo();
        //    tituloBE.DataOrdem = ordemOriginal.DataOrdem.Value;
        //    tituloBE.TipoMercado = ordemEntrada.TipoMercado.Value;
        //    tituloBE.Titulo = ordemEntrada.Titulo;
        //    tituloBE = tituloRA.ConsultarCodigoIsinDataVencimento(tituloBE);

        //    ///caso n encontre o titulo q contem o codigo isin
        //    if (tituloBE == null)
        //        throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_TITULONAOENCONTRADO);

        //    ordemEntrada.IndicadorDistribuicao = "N";
        //    ordemEntrada.IndicadorChamadaLog = false;
        //    ordemEntrada.CodigoISIN = tituloBE.CodigoISIN;
        //    ordemEntrada.CodigoUsuarioConectado = Sinacor.Infra.Service.Security.Authorization.AuthorizationContext.Current.UserId;
        //    ordemEntrada.CodigoUsuarioOrdem = ordemOriginal.CodigoUsuarioOrdem;
        //    ordemEntrada.CodigoCliente = ordemOriginal.CodigoCliente;
        //    ordemEntrada.DataValidade  = ordemOriginal.DataValidade;
        //    ordemEntrada.TipoOrdem = ordemOriginal.TipoOrdem;
        //    ordemEntrada.Bolsa = ordemOriginal.Bolsa;
					
        //    ///realizar as desvidas validacoes na ordem sendo incluida
        //    retorno = ValidarAlteracaoOrdemFinanciamentoPOP(ordemBase,ordemOriginal, ordemEntrada);

        //    ///caso a ordem esteja bloqueada nao permitir 
        //    if (retorno == null || retorno.VerificacaoBloqueio == null)
        //    {
        //        //Se diminuiu a quantidade
        //        if (ordemOriginal.Quantidade > ordemEntrada.Quantidade)
        //        {
        //            ////TODO - ESTA COM ERRO POR CONTA DO COMMIT INTERNO
        //            ordemRA.AtualizarDetalheExecucao(ordemOriginal);
        //            ///zerar a quantidade casada
        //            ordemEntrada.QuantidadeCasada = 0;
        //        }
        //        else
        //        {
        //            ///manter a quantidade casada original
        //            ordemEntrada.QuantidadeCasada = ordemOriginal.QuantidadeCasada;
        //        }

        //        if (ordemRA.AlterarOrdemFinanciamentoPOP(ordemEntrada) != 1)
        //            throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_ORDEMNAOALTERADA);
        //        else
        //        {
        //            ///verificar se ha saldo negociavel apos alterar a ordem (conforme especificado)
        //            mensagemVerificacao = ordemRA.VerficarSaldoNegociavel(ordemEntrada);
        //            if (!String.IsNullOrEmpty(mensagemVerificacao))
        //            {
        //                if (retorno == null)
        //                    retorno = new BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP();

        //                retorno.MensagemVerificacaoSaldoNegociavel = new Sinacor.Servico.Bovespa.BovespaBase.BusinessEntity.MensagemValidacao();
        //                retorno.MensagemVerificacaoSaldoNegociavel.Codigo = 0;//TODO
        //                retorno.MensagemVerificacaoSaldoNegociavel.Descricao = mensagemVerificacao;
        //            }
        //            else
        //                retorno = null;
        //        }
        //    }

        //    return retorno;
        //}

        ///// <summary>
        ///// Metodo responsavel por validar a alteracao ordens financiamento pop
        ///// Data: 11/12/2007
        ///// Autor: Diogo Milanez
        ///// Obs: Criacao do metodo
        ///// 
        ///// Data: 19/12/2007
        ///// Autor: Diogo Milanez
        ///// Obs: 
        ///// * Retorno foi alterado de void para BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP
        ///// * Adicionado parametro de entrada ordemBase
        ///// </summary>
        ///// <param name="ordemBase">ordem base da sub-ordem (sub-sequencia = 0)</param>
        ///// <param name="ordemOriginal">ordem atualmente cadastrada na base</param>
        ///// <param name="ordemEntrada">ordem alterada</param>
        //private BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP ValidarAlteracaoOrdemFinanciamentoPOP(BusinessEntity.Ordem ordemBase, BusinessEntity.Ordem ordemOriginal, BusinessEntity.Ordem ordemEntrada)
        //{
        //    ResourceAccess.Ordem ordemRA = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();
        //    ResumoFinanceiro.ResourceAccess.Comitente comitenteRA = new ResumoFinanceiro.ResourceAccess.Comitente();
        //    Calendario.ResourceAccess.Calendario calendarioRA = new Calendario.ResourceAccess.Calendario();
        //    BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP response = null;
        //    DateTime? dataCalendario, dataMovimento;
        //    ResourceAccess.OrdemMegaBolsa ordemMegaRA = new ResourceAccess.OrdemMegaBolsa();

        //    response = ValidarOrdemFinanciamentoPOP(ordemBase, ordemEntrada);

        //    ///checar se a ordem foi aberta pelo megabolsa		
        //    if (ordemMegaRA.VerificarOrdemMegaBolsa(ordemEntrada))
        //        throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_ORDEMABERTAMEGABOLSA);

        //    if (!VerificarValidadeAlteravel(ordemEntrada))
        //        throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_VALIDADE_NAO_ALTERAVEL);

        //    //Se TORMOVD.DT_VALORD < TORDATMOV.DT_DATMOV deve existir permissão 'D1SIM' para efetuar alterações
        //    if (ordemOriginal.DataValidade < Calendario.ResourceAccess.DataMovimento.RecuperarDataMovimento())
        //    {
        //        if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("D1SIM"))
        //            throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_PERMISSAONEGADA);
        //    }

        //    return response;
        //}
        #endregion REMOVIDO SEGUNDO ORIENTACAO DO ANALISTA SINACOR (KLEBER)

        #endregion Alterar Ordens Financiamento POP

        #region Excluir Ordens Financiamento POP
        /// <summary>
		/// Cancelar ordens financiamento Pop
        /// 
        /// O casamento não esta sendo executado ao final da operacao devido a questoes
        /// de performance (pelo fato de salvar uma ordem por vez) isso foi validado com o analista sinacor (Nemir)
        /// 
		/// Data: 11/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
        /// 
        /// Data: 04/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Metodo renomeado de ExcluirOrdensFinanciamentoPOP para CancelarOrdemFinanciamentoPOP
        /// Retorno foi alterado de void para RetornoMetodosOrdemFinanciamentoPOP
        /// Parametro de entrada foi alterado de lista para objeto
        /// 
        /// Data : 28/02/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Metodo ValidarChaveOrdem() foi copiado para fora do metodo ValidarCancelamentoOrdemFinanciamentoPOP, 
        /// para antes da consulta da ordem.
        /// Obs. : Incluida validacao do cancelamento da ordem verificando quantidade de linhas afetadas no update.
        /// 
        /// Data : 22/04/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Metodo renomeado de (CancelarOrdemFinanciamentoPOP) para (ExcluirOrdemFinanciamentoPOP) - esertorio - 200804221512 - ref issue ID0003284 - ref issue ID0003560
        /// </summary>
		/// <param name="request"></param>
        public BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP ExcluirOrdemFinanciamentoPOP(BusinessEntity.Ordem request) //renomeado - esertorio - 200804221512 - ref isue ID0003284
        {
            BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP response = null;
            Ordens.ResourceAccess.Ordem ordemRA = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();

            //incluido -  validar chave antes de consultar a ordem - eduardo sertorio - 200802281224
            ValidarChaveOrdem(request);

            ///consultar os dados da ordem a ser excluida
            request = ConsultarOrdem(request);

            ValidarCancelamentoOrdemFinanciamentoPOP(request);

            ordemRA.AtualizarDetalheExecucao(request);

            request.CodigoUsuarioConectado = Sinacor.Infra.Service.Security.Authorization.AuthorizationContext.Current.UserId;

            int retorno = ordemRA.CancelarOrdem(request); //alterado - eduardo sertorio - 200802281257

            if (retorno != 1)
                throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_ORDEMNAOALTERADA); //incluido - eduardo sertorio - 200802281257

            ///verificar o saldo negociavel apos o cancelamento da ordem
            string temp = ordemRA.VerficarSaldoNegociavel(request);
            if (!String.IsNullOrEmpty(temp))
            {
                response = new Ordens.BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP();
                response.MensagemVerificacaoSaldoNegociavel = new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.MensagemValidacao();
                response.MensagemVerificacaoSaldoNegociavel.Codigo = 0;
                response.MensagemVerificacaoSaldoNegociavel.Descricao = temp;
            }

            return response;
		}

		/// <summary>
		/// Metodo responsavel por validar a exclusao ordens financiamento pop
		/// Data: 11/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
        /// 
        /// Data : 28/02/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Revisao e teste.
        /// </summary>
		/// <param name="request"></param>
		private void ValidarCancelamentoOrdemFinanciamentoPOP(BusinessEntity.Ordem request)
		{
            ///verificar se a chave da ordem foi informada
            ValidarChaveOrdem(request);

            ///verificar se a ordem foi aberta pelo megabolsa          
            if ((new ResourceAccess.OrdemMegaBolsa()).VerificarOrdemMegaBolsa(request))
                throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_ORDEMABERTAMEGABOLSA);

            //Se TORMOVD.DT_VALORD < TORDATMOV.DT_DATMOV deve existir permissão 'D1SIM' para efetuar alterações
            if (request.DataValidade < (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento())
            {
                if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("D1SIM"))
                    throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_PERMISSAONEGADA);
            }

            ///verificar se possui a validade alteravel
            if (!VerificarValidadeAlteravel(request))
                throw new BusinessException(ERRO_ORDEMFINANCIAMENTOPOP_VALIDADE_NAO_ALTERAVEL);

        }
        
        #endregion Excluir Ordens Financiamento POP

        #region Gerais

        /// <summary>
		/// Metodo responsavel por verificar se um ordem é POP
		/// Data: 12/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
		/// </summary>
		/// <param name="request"></param>
		/// <returns></returns>
		private bool VerificarOrdemPOP(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Ordem request)
		{
			/// POP : substr( TORMOVD.CD_CODISI, 6, 2 ) = 'PP' ( contando a partir do zero )
			//	            para a subsequência = 0
			if (String.IsNullOrEmpty(request.CodigoISIN) || request.CodigoISIN.Length < 9)
				return false;
			else if (request.CodigoISIN.Substring(6, 2) == "PP")
				return true;
			else
				return false;
		}

		/// <summary>
		/// Metodo responsavel por verificar se um ordem é Financiamento
		/// Data: 12/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
		/// </summary>
		/// <param name="request"></param>
		/// <returns></returns>
		private bool VerificarOrdemFinanciamento(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Ordem request)
		{
			//Financiamento : TORMOVD.TP_ORDEM com o número 6 na dezena ou na unidade
            if (request.TipoOrdem == null || request.TipoOrdem.Count == 0)
				return false;
			else if (request.TipoOrdem.Contains(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoOrdem.Financiamento))
				return true;
			else
				return false;
		}

		/// <summary>
		/// Metodo responsavel por realizar o casamento financeiro de ordens financimento POP
		/// Data: 14/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
        /// 
        /// Data : 28/02/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Inclusao de validacao da chave da ordem e da DataPregao.
        /// </summary>
		/// <param name="preBoleto"></param>
		/// <returns></returns>
		public BusinessEntity.RetornoCasamento RealizarCasamentoOrdemFinanciamentoPOP(BusinessEntity.Ordem request)
		{
			string msgRetorno;
			BusinessEntity.RetornoCasamento retorno;
			ResourceAccess.PreBoleto preBoletoRA = new ResourceAccess.PreBoleto();
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();

            //incluido - eduardo sertorio - 200802281711
            ValidarChaveOrdem(request);

            //incluido - eduardo sertorio - 200802281711
            if (!request.DataPregao.HasValue || request.DataPregao.Equals(DateTime.MinValue))
            {
                ValidationException validationException = new ValidationException();
                validationException.AddError(ERRO_DATA_PREGAO_NAO_INFORMADA);
                throw validationException;
            }

			retorno = preBoletoRA.RealizarCasamento(request, BusinessEntity.Enum.TipoCasamentoPreBoleto.FIN);

			///recuperar o codigo do cliente a ser utilizado na varificacao de compliance e calculo financeiro
			request.CodigoCliente = ordemRA.ConsultarCodigoCliente(request);

			if (retorno != null)
			{
						///se casamento total ou parcial
				if (retorno.TipoRetornoCasamento == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoRetornoCasamento.CasamentoTotal ||
					retorno.TipoRetornoCasamento == Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.TipoRetornoCasamento.CasamentoParcial
					)
				{
					///verificar compliance
					if ( (new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarInCompliance() == "S")
					{
						///realizar as verificacoes de compliance
						msgRetorno = this.VerificarCompliance(request);
						if (!String.IsNullOrEmpty(msgRetorno))
						{
                            retorno.MensagemVerificacaoCompliance = new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.MensagemValidacao();
							retorno.MensagemVerificacaoCompliance.Codigo = 0;
							retorno.MensagemVerificacaoCompliance.Descricao = msgRetorno;
						}
					}

					ordemRA.RealizarCalculoFinanceiro(request, "RealizarCasamentoOrdemFinanciamentoPOP");
				}
			}

			return retorno;

		}

		/// <summary>
		/// Metodo responsavel por realizar as validacoes comuns a inclusao e alteracao de ordens financiamento / pop
		/// Data: 11/12/2007
		/// Autor: Diogo Milanez
		/// Obs: Criacao do metodo
		/// </summary>
		/// <param name="request"></param>
		private BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP ValidarOrdemFinanciamentoPOP(BusinessEntity.Ordem ordemBase, BusinessEntity.Ordem ordemEntrada)
		{
			ResourceAccess.Ordem ordemRA = new ResourceAccess.Ordem();
			BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP retorno = new BusinessEntity.RetornoMetodosOrdemFinanciamentoPOP();
			retorno.VerificacaoBloqueio = VerificarBloqueio(ordemEntrada);

			if (retorno.VerificacaoBloqueio != null)
				return retorno;

            ValidarCarteiraOrdemFinanciamentoPOP(ordemEntrada);
			ValidarMercadoOrdemFinanciamentoPOP(ordemBase, ordemEntrada);
			ValidarVencimentoTermoOrdemFinanciamentoPOP(ordemEntrada);
			ValidarPrecoPapelOrdemFinancimentoPOP(ordemEntrada);
            ValidarQuantidadeOrdemFinanciamentoPOP(ordemEntrada);

			return retorno;
		}

        /// <summary>
        /// Data: 03/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Metodo responsavel por validar os dados de entrada dos metodos
        /// de inclusao e alteracao de ordens financiamento/pop
        /// </summary>
        /// <param name="ordemEntrada"></param>
        private void ValidarDadosEntradaOrdemFinanciamentoPOP(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Ordem ordemEntrada)
        {
            ValidationException ex = new ValidationException();
            try
            {
                ValidarChaveOrdem(ordemEntrada);
            }
            catch (ValidationException ex1)
            {
                ex = ex1;
            }

            if (!ordemEntrada.NaturezaOperacao.HasValue)
                ex.AddError(ERRO_NATUREZA_OPERACAO_NAO_INFORMADA);

            if (!ordemEntrada.TipoMercado.HasValue)
                ex.AddError(ERRO_TIPO_MERCADO_NAO_INFORMADO);
            else
                if (ordemEntrada.TipoMercado.Value.Equals(TipoMercado.Termo)) //incluido - esertorio - 200804231101 - ref issue ID0003542
                    if (!ordemEntrada.VencimentoTermo.HasValue) //mudou de lugar para ca - esertorio - 200804231101 - ref issue ID0003542
                        ex.AddError(ERRO_VENCIMENTO_TERMO_NAO_INFORMADO);

            if (String.IsNullOrEmpty(ordemEntrada.Titulo))
                ex.AddError(ERRO_CODIGO_NEGOCIACAO_NAO_INFORMADO);

            if (!ordemEntrada.Quantidade.HasValue)
                ex.AddError(ERRO_QUANTIDADE_NAO_INFORMADA);

            if (!ordemEntrada.Preco.HasValue)
                ex.AddError(ERRO_PRECO_NAO_INFORMADO);

            if (!ordemEntrada.DataPregao.HasValue) //corrigido para validar nulo - esertorio - 200804231101 - ref issue ID0003542
                ex.AddError(ERRO_DATA_PREGAO_NAO_INFORMADA);

            if (ex.ValidationErrors != null && ex.ValidationErrors.Count > 0)
                throw ex;
        }

        /// <summary>
        /// Metodo responsavel por verificar se a chave da ordem foi informada
        /// Data: 04/01/2008
        /// Autor: Diogo Milanez
        /// Obs: Criacao do metodo
        /// </summary>
        /// <param name="ordemEntrada"></param>
        /// <returns></returns>
        private void ValidarChaveOrdem(Ordens.BusinessEntity.Ordem ordemEntrada)
        {
            ValidationException ex = new ValidationException();

            if (!ordemEntrada.NumeroOrdem.HasValue)
                ex.AddError(ERRO_NUMERO_ORDEM_NAO_INFORMADO);

            if (!ordemEntrada.NumeroOrdemSubSequencia.HasValue)
                ex.AddError(ERRO_NUMERO_SUBSEQUENCIA_ORDEM_NAO_INFORMADO);

            if (!ordemEntrada.DataOrdem.HasValue)
                ex.AddError(ERRO_DATA_ORDEM_NAO_INFORMADA);

            if (ex.ValidationErrors != null && ex.ValidationErrors.Count > 0)
                throw ex;
        }

        /// <summary>
        /// Data: 03/01/2008
        /// Autor: Diogo Milanez
        /// Obs:
        /// Metodo responsavel por verificar se uma ordem tem a validade alteravel
        /// </summary>
        /// <param name="ordemOriginal"></param>
        /// <param name="ordemEntrada"></param>        
        private bool VerificarValidadeAlteravel(BusinessEntity.Ordem ordemEntrada)
        {
            ResumoFinanceiro.ResourceAccess.Comitente comitenteRA = new ResumoFinanceiro.ResourceAccess.Comitente();
            Sinacor.Servico.Bovespa.Calendario.ResourceAccess.Calendario calendarioRA = new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.Calendario();
            DateTime? dataCalendario, dataMovimento;

            ///checar se a validade é alteravel			
            dataCalendario = calendarioRA.RecuperarMenorDataMovimentoCalendarioPraca(ordemEntrada.Bolsa);
            dataMovimento = comitenteRA.RecuperarMenorDataNegocioComitente(ordemEntrada.Bolsa, ordemEntrada.DataOrdem.Value, ordemEntrada.NumeroOrdem.Value, ordemEntrada.NumeroOrdemSubSequencia.Value);

            return !(dataCalendario > dataMovimento);
        }

		#endregion Gerais

        #endregion Financiamento POP

        #region Codigo Adicionado por Ludmilla

        /// <summary>
        /// Historico:
        /// Data : 20/12/2007
        /// Autor: Ludmilla Modesto 
        /// Obs.: Criado. Retorna as mensagens de Justificativa e observacao
        /// </summary>
        /// <returns></returns>
        public List<BusinessEntity.Mensagem> ConsultarMensagensJustificativaObservacao()
        {

            ResourceAccess.Mensagem raMensagem = new ResourceAccess.Mensagem();
            List<BusinessEntity.Mensagem> beMensagemCollection = null;

            beMensagemCollection = raMensagem.ConsultarMensagensJustificativaObservacao();

            return beMensagemCollection;

        }

        /// <summary>
        /// Servico responsavel por Inserir uma Justificativa
        /// Historico:
        /// Data: 26/12/2007
        /// Autor: Ludmilla Modesto 
        /// Observacao: Criacao da Operacao
        /// 
        /// Data : 20/02/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Incluido validacao da quantidade de linhas incluidas - eduardo sertorio - 200802201220
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public void IncluirJustificativa(BusinessEntity.Justificativa request)
        {
            // fazer no BL 
            if (String.IsNullOrEmpty(request.TextoJustificativa.Trim()))
            {
                ValidationException ex = new ValidationException();
                ex.AddError(ERRO_JUSTIFICATIVADEVESERINFORMADA);
                throw ex;
            }
            else
            {
                ResourceAccess.Justificativa raJustificativa = new ResourceAccess.Justificativa();
                int retorno = raJustificativa.InserirJustificativa(request);
                if (retorno != 1) //incluido validacao da quantidade de linhas incluidas - eduardo sertorio - 200802201220
                    throw new BusinessException(ERRO_JUSTIFICATIVA_NAOEXISTEJUSTIFICATIVAPARAESTAORDEM);
            }
        }

        /// <summary>
        /// Servico responsavel por Atualizar uma Justificativa
        /// Historico:
        /// Data: 26/12/2007
        /// Autor: Ludmilla Modesto 
        /// Observacao: Criacao da Operacao
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public void AlterarJustificativa(BusinessEntity.Justificativa request)
        {
            if (String.IsNullOrEmpty(request.TextoJustificativa.Trim()))
            {
                ValidationException ex = new ValidationException();
                ex.AddError(ERRO_JUSTIFICATIVADEVESERINFORMADA);
                throw ex;
            }
            else
            {
                ResourceAccess.Justificativa raJustificativa = new ResourceAccess.Justificativa();
                int retorno = raJustificativa.AlterarJustificativa(request); //alterado - incluido captura do retorno - eduardo sertorio - 200802201126
                if (retorno != 1) //incluido validacao do retorno - eduardo sertorio - 200802201126
                    throw new BusinessException(ERRO_JUSTIFICATIVA_NAOEXISTEJUSTIFICATIVAPARAESTAORDEM);
            }
        }


        /// <summary>
        /// Servico responsavel por Consultar uma Justificativa
        /// Historico:
        /// Data: 26/12/2007
        /// Autor: Ludmilla Modesto 
        /// Observacao: Criacao da Operacao
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public List<BusinessEntity.Justificativa> ConsultarJustificativas(BusinessEntity.Justificativa request)
        {
            ResourceAccess.Justificativa raJustificativa = new ResourceAccess.Justificativa();
            List<BusinessEntity.Justificativa> beJustificativaCollection = null;

            beJustificativaCollection = raJustificativa.ConsultarJustificativas(request);

            if (beJustificativaCollection == null)
                throw new BusinessException(ERRO_JUSTIFICATIVA_NAOEXISTEJUSTIFICATIVAPARAESTAORDEM);
            else
                return beJustificativaCollection;

        }

        /// <summary>
        /// Servico responsavel por trazer a observacao de uma ordem
        /// Historico:
        /// Data: 27/12/2007
        /// Autor: Ludmilla Modesto 
        /// Observacao: Criacao da Operacao
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public BusinessEntity.Observacao ConsultarObservacao(BusinessEntity.Observacao request)
        {
            ResourceAccess.Observacao raObservacao = new ResourceAccess.Observacao();
            BusinessEntity.Observacao beObservacao = raObservacao.ConsultarObservacao(request);
            return beObservacao;
        }

        /// <summary>
        /// Servico responsavel por alterar ou inserir uma observacao de uma ordem
        /// Historico:
        /// Data: 28/12/2007
        /// Autor: Ludmilla Modesto 
        /// Observacao: Criacao da Operacao
        /// 
        /// Data : 21/02/2009
        /// Autor: Eduardo Sertorio
        /// Obs. : Incluido trecho para validar a ordem e obter hora da ordem
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public void AlterarObservacao(BusinessEntity.Observacao request)
        {
            if (!request.Ordem.DataOrdem.HasValue)
                validationException.AddError(ERRO_ORDEM_DATAORDEMNAOINFORMADA);

            if(!request.Ordem.NumeroOrdem.HasValue)
                validationException.AddError(ERRO_ORDEM_NUMERONAOINFORMADO);

            if(!request.Ordem.NumeroOrdemSubSequencia.HasValue)                
                validationException.AddError(ERRO_ORDEM_NUMEROSEQUENCIANAOINFORMADO);

            if (String.IsNullOrEmpty(request.Descricao.Trim()))
                validationException.AddError(ERRO_ORDEM_OBSERVACAONAOINFORMADO);

            if (validationException.ValidationErrors != null && validationException.ValidationErrors.Count > 0)
                throw validationException;

            //incluido para validar ordem e obter hora da ordem - 200802211755
            BusinessEntity.Ordem beOrdem = new ResourceAccess.Ordem().ConsultarOrdem(request.Ordem);
            
            if (beOrdem == null)
                throw new BusinessException(ERRO_ORDEM_ORDEMINVALIDA);
            
            request.Ordem.HoraOrdem = beOrdem.HoraOrdem.Value;

            int retorno = (new ResourceAccess.Observacao()).AlterarObservacao(request);

            if (retorno != 1)
                throw new BusinessException(ERRO_ORDEM_OBSERVACAOINEXISTENTE);
        }

        #endregion Codigo Adicionado por Ludmilla

        #region Recuperar Parametro Controle Ordens

        /// <summary>
        /// Data : 08/04/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Criacao do metodo
        /// </summary>
        /// <returns></returns>
        public Sinacor.Servico.Bovespa.Ordens.BusinessEntity.ParametroControleOrdens RecuperarParametroControleOrdens()
        {
            Sinacor.Servico.Bovespa.Ordens.BusinessEntity.ParametroControleOrdens response = new Sinacor.Servico.Bovespa.Ordens.BusinessEntity.ParametroControleOrdens();

            response.IndicadorDigitoAberturaOrdem = (new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarIndicadorDigitoAberturaOrdem().Equals("S");
            response.IndicadorAtualizacaoQuantidadeOrdemPreboleto = (new Sinacor.Servico.Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarIndicadorAtualizacaoQuantidadeOrdemPreBoleto().Equals("S"); //20080420 19:41 - RValadao.7Comm - Bug 0003345

            return response;
        }

        #endregion Recuperar Parametro Controle Ordens


        /// <summary>
        /// Metodo responsavel por validar a data do pregao para acesso ao pre-boleto de ordens da mega bolsa
        /// Data : 07/12/2007
        /// Autor: Eduardo Sertorio
        /// Obs. : Criacao do metodo
        /// 
        /// Data : 28/04/2008
        /// Autor: Eduardo Sertorio
        /// Obs. : Alteracao do metodo para tornar-se generico para ordens mega bolsa ou normal
        /// Obs. : O metodo nao foi movimentado para classe Ordem para poupar o impacto na mudança das constantes de erro
        /// 
        /// //comentario adicionado - esertorio - 200805291953 - ref issue ID0004727
        /// Data : 28/04/2008 (ainda no mesmo dia ...)
        /// Autor: Eduardo Sertorio
        /// Obs. : O metodo FOI movimentado da classe OrdemMegaBolsa para classe Ordem para tornar-se generico para ordens mega bolsa ou normal
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public void ValidarDataPregaoPreBoletoOrdem(BusinessEntity.Ordem ordemAlterada, DateTime dataPregaoPreBoleto)
        {
            BusinessEntity.Ordem beOrdem = new BusinessEntity.Ordem();
            BusinessEntity.Ordem beOrdemOriginal = new BusinessEntity.Ordem();
            ResourceAccess.Ordem raOrdem = new ResourceAccess.Ordem();

            //se nao tem permissao para incluir (IORD), nem para alterar (AORD) e nem para excluir (EORD)
            if (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("IORD") //incluido - esertorio - 200805291933 - ref issue ID0004727
                &&
                !Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("AORD") //incluido - esertorio - 200805291933 - ref issue ID0004727
                &&
                !Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("EORD") //incluido - esertorio - 200805291933 - ref issue ID0004727
                )
            {
                //constante de erro reaproveitada - esertorio - 200805291956
                throw new BusinessException(ERRO_ORDEM_SEMPERMISSAOALTERARORDEM); //incluido - esertorio - 200805291933 - ref issue ID0004727
            }

            if (!ordemAlterada.DataValidade.HasValue) //incluido - esertorio - 200805032111 - ref issue ID0004007
            {
                ValidationException validationException = new ValidationException();
                validationException.AddError(ERRO_ORDEM_DATAVALIDADENULO); //incluido - esertorio - 200805032111 - ref issue ID0004007
                throw validationException;
            }

            //movido - ini bloco - esertorio - 200805291922 - ref issue ID0004727
            DateTime dataMovimento = (new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.DataMovimento()).RecuperarDataMovimento();

            //   -- Não permitir acesso à tela de alteração de pré-boleto 
            //         se ( TORMOVD.DT_DATORD ) < data do sistema ( TORDATMOV.DT_DATMOV )
            //         e nao existir permissão para a função D1SIM
            //20080425 18:42 - RValadao
            //Movido para o início da validação, resolução do bug 3641
            //20080504 17:49 - Rvaladao
            //Alterado parametro parametro DataOrdem para  DataValidade, conforme bug 3967
            if (
                (ordemAlterada.DataValidade < dataMovimento)
                && (!Sinacor.Servico.Bovespa.Acesso.BusinessLogic.Acesso.VerificarAcessoFuncao("D1SIM"))
                )
            {
                throw new BusinessException(ERRO_ORDEM_SEMPERMISSAOALTERARORDEMDATAANTERIOR); //"Usuário não possui permissão para alterar ordem com data anterior a data de movimento."
            }
            //movido - fim bloco - esertorio - 200805291922 - ref issue ID0004727

            //incluido - rvaladao - 20080512 11:49 - ref issue ID0004728
            if (ordemAlterada.DataOrdem > dataPregaoPreBoleto)
            {
                throw new BusinessException(ERRO_ORDEM_DATAPREGAOMENORDATAORDEM); //incluido - rvaladao - 20080512 11:49 - ref issue ID0004728
            }

            //incluido - rvaladao - 20080512 11:49 - ref issue ID0004728
            if (ordemAlterada.DataValidade < dataPregaoPreBoleto)
            {
                throw new BusinessException(ERRO_CONSULTAORDENSNEGOCIOS_DATAPREGAOINVALIDA); //incluido - rvaladao - 20080512 11:49 - ref issue ID0004728
            }

            //guarda objeto da ordem alterada em variavel auxiliar para nao perde-lo.
            beOrdem = ordemAlterada;

            //obtem ordem original do banco de dados.
            beOrdemOriginal = raOrdem.ConsultarOrdem(beOrdem);

            if (beOrdemOriginal == null)
            {
                throw new BusinessException(ERRO_ORDEM_ORDEMINVALIDADATAPREGAOPREBOLETO); //"Ordem mega bolsa inválida para validação da data do pregão para pré-boleto."
            }

            //coloca ordem original no lugar da ordem recebida pela funcao.
            ordemAlterada = beOrdemOriginal;

            //11.
            //-- Validação da Data do pregão para acessar tela de Pré-boleto
            //   -- Data do Movimento ( TORDATMOV.DT_DATMOV ) deve ser <= Validade da Ordem (TORMOVD.DT_VALORD)
            if (!(dataMovimento <= ordemAlterada.DataValidade))
            {
                throw new BusinessException(ERRO_ORDEM_DATAMOVIMENTOMAIORDATAVALIDADE); //"Data do Movimento deve ser menor ou igual a Data da validade da Ordem."
            }

            //   -- Ordem deve estar marcada para casar ( TORMOVD.IN_CASAORD )
            if (!ordemAlterada.IndicadorOrdemFilaCasamento.HasValue || !ordemAlterada.IndicadorOrdemFilaCasamento.Value)
            {
                throw new BusinessException(ERRO_ORDEM_ORDEMSEMMARCACASAMENTO); //"Ordem não está marcada para casar."
            }

            //   -- A DATA_PREGA0_BOTAO_PREBOLETO deve esta contida na DISTINCT(TBOCALE.DT_MOV) (Nemir - 20071207)
            if (!((new Sinacor.Servico.Bovespa.Calendario.ResourceAccess.Calendario()).ValidarDataPregaoPreBoletoCalendario(dataPregaoPreBoleto)))
            {
                throw new BusinessException(ERRO_ORDEM_DATAPREGAOPREBOLETOINVALIDA); //"Data do pregão inválida para pré-boleto."
            }

            //excluido - Eduardo Sertorio - 20080102
            //sobreviveu aa validacao
            //response = true;

            //excluido - Eduardo Sertorio - 20080102
            //return response;
        }

        /// <summary>
        /// Autor: LLiez.7comm
        /// Padrao = Chamar metodo da Resouce chamado ConsultarOrdemDiscricionaria
        /// Operador = Chamar metodo da Resource chamado ConsultarOrdemDiscricionariaPorOperador
        /// Ordem = Chamar metodo da Resource chamado ConsultarOrdemDiscricionariaPorOrdem
        /// POP = Chamar metodo da Resource chamado
        /// ConsultarOrdemDiscricionariaPorPOP
        /// Deve identificar atraves do enum qual o tipo de agrupamento
        /// Padrao = Chamar metodo da Resouce chamado ConsultarOrdemDiscricionaria
        /// Operador = Chamar metodo da Resource chamado ConsultarOrdemDiscricionariaPorOperador
        /// Ordem = Chamar metodo da Resource chamado ConsultarOrdemDiscricionariaPorOrdem 
        /// </summary>
        /// <param name="request"></param>
        /// <param name="grupo"></param>
        /// <returns></returns>
        public List<BusinessEntity.Ordem> ConsultarOrdemDistribuicao(BusinessEntity.Parameter.ConsultarOrdemDistribuicao request)
        {
            List<BusinessEntity.Ordem> ordemResp = null;
            // TODO: reativar linhas abaixo quando JuntaFracionario estiver funcionando
            Bovespa.Parametro.BusinessEntity.Parametro parametro = (new Bovespa.Parametro.BusinessLogic.Parametro()).RecuperarJuntaFracionario();
            request.JuntaFracionario = parametro.JuntaFracionario.ToString();

            switch (request.OrdemDistribuicaoGrupo)
            {
                case OrdemDistribuicaoGrupo.Padrao:
                    ordemResp = (new ResourceAccess.Ordem()).ConsultarOrdemDistribuicao(request);
                    break;

                case OrdemDistribuicaoGrupo.Operador:
                    ordemResp = (new ResourceAccess.Ordem()).ConsultarOrdemDistribuicaoPorOperador(request);
                    break;

                case OrdemDistribuicaoGrupo.Ordem:
                    ordemResp = (new ResourceAccess.Ordem()).ConsultarOrdemDistribuicaoPorOrdem(request);
                    break;

                case OrdemDistribuicaoGrupo.POP:
                    ordemResp = (new ResourceAccess.Ordem()).ConsultarOrdemDistribuicaoPorPOP(request);
                    break;

                case OrdemDistribuicaoGrupo.AdministradoConcorrente:
                    ordemResp = (new ResourceAccess.Ordem()).ConsultarOrdemDistribuicaoPorAdministradoConcorrente(request);
                    break;
            }
            
            /*
            if (ordemResp == null || ordemResp.Count == 0)
                throw new BusinessException(ERRO_PESQUISA_SEM_RESULTADO);            
            */

            return ordemResp;
        }

        public List<BusinessEntity.Ordem> ConsultarOrdemDistribuicaoOrdem(BusinessEntity.Parameter.ConsultarOrdemDistribuicaoOrdem pConsultarOrdemDistribuicaoOrdem)
        {
            if (pConsultarOrdemDistribuicaoOrdem.ApelidoCliente == null )
                throw new BusinessException(ERRO_ORDEM_NOMECLIENTENULO);

            if ( pConsultarOrdemDistribuicaoOrdem.CodigoBolsa == null )
                throw new BusinessException(ERRO_ORDEM_CLIENTEINVALIDOPARABOLSAINFORMADA);

             if ( String.IsNullOrEmpty(pConsultarOrdemDistribuicaoOrdem.CodigoNegocio) )
                throw new BusinessException(ERRO_ORDEM_TITULONULO);

             if ( pConsultarOrdemDistribuicaoOrdem.DataPregao == null )
                throw new BusinessException(ERRO_ORDEM_DATAORDEMNAOINFORMADA);

             if ( pConsultarOrdemDistribuicaoOrdem.NaturezaOperacao == null )
                 throw new BusinessException(ERRO_ORDEM_NATUREZAOPERACAONULO);

             if (pConsultarOrdemDistribuicaoOrdem.DataOrdem == null)
                 throw new BusinessException(ERRO_DATA_ORDEM_NAO_INFORMADA);

             if (pConsultarOrdemDistribuicaoOrdem.IsDiscricionaria == null)
                 throw new BusinessException(ERRO_ORDEM_ISDISCRICIONARIA);

             if (pConsultarOrdemDistribuicaoOrdem.NumeroOrdem == null)
                 throw new BusinessException(ERRO_NUMERO_ORDEM_NAO_INFORMADO);

             if (pConsultarOrdemDistribuicaoOrdem.NumeroSubSequenciaOrdem == null)
                 throw new BusinessException(ERRO_NUMERO_SUBSEQUENCIA_ORDEM_NAO_INFORMADO);
            
    

            return new ResourceAccess.Ordem().ConsultarOrdemDistribuicaoOrdem(pConsultarOrdemDistribuicaoOrdem);
        }


        public List<BusinessEntity.Ordem> ConsultarOrdemDistribuicaoOrdemPadrao(BusinessEntity.Parameter.ConsultarOrdemDistribuicaoOrdemPadrao pConsultarOrdemDistribuicaoOrdemPadrao)
        {
            if (pConsultarOrdemDistribuicaoOrdemPadrao.ApelidoCliente == null)
                throw new BusinessException(ERRO_ORDEM_NOMECLIENTENULO);

            if (pConsultarOrdemDistribuicaoOrdemPadrao.CodigoBolsa == null)
                throw new BusinessException(ERRO_ORDEM_CLIENTEINVALIDOPARABOLSAINFORMADA);

            if (String.IsNullOrEmpty(pConsultarOrdemDistribuicaoOrdemPadrao.CodigoNegocio))
                throw new BusinessException(ERRO_ORDEM_TITULONULO);

            if (pConsultarOrdemDistribuicaoOrdemPadrao.DataPregao == null)
                throw new BusinessException(ERRO_ORDEM_DATAORDEMNAOINFORMADA);

            if (pConsultarOrdemDistribuicaoOrdemPadrao.NaturezaOperacao == null)
                throw new BusinessException(ERRO_ORDEM_NATUREZAOPERACAONULO);

            return new ResourceAccess.Ordem().ConsultarOrdemDistribuicaoOrdemPadrao(pConsultarOrdemDistribuicaoOrdemPadrao);
        }


        public List<BusinessEntity.Ordem> ConsultarOrdemDistribuicaoOrdemLote(List<BusinessEntity.Parameter.ConsultarOrdemDistribuicaoOrdemLote> pConsultarOrdemDistribuicaoOrdem)
        {

            if (pConsultarOrdemDistribuicaoOrdem.Count == 0)
            {
                //throw new BusinessException(ERRO_ORDEM_NATUREZAOPERACAONULO);
            }

            return new ResourceAccess.Ordem().ConsultarOrdemDistribuicaoOrdemLote(pConsultarOrdemDistribuicaoOrdem);
        }

        ///<sumary>
        /// Converte Tipo de Liquidacao de String para Enum
        /// Data: 17/12/2007
        /// Autor: Eduarddo Sertorio
        /// Observacoes: Criacao
        /// 
        /// Data : 20/02/2008
        /// Autor: Eduarddo Sertorio
        /// Obs. : Revisao
        ///<sumary>
        public static BusinessEntity.Enum.TipoLiquidacao StringToEnum(string value)
        {
            BusinessEntity.Enum.TipoLiquidacao retorno;
            switch (value)
            {

                case "C":
                    retorno = BusinessEntity.Enum.TipoLiquidacao.Custodiante;
                    break;
                case "A":
                    retorno = BusinessEntity.Enum.TipoLiquidacao.Normal;
                    break;
                case null: // representado por nulo no banco de dados - incluido - eduardo sertorio - 200802201747
                    retorno = BusinessEntity.Enum.TipoLiquidacao.Normal; //incluido - eduardo sertorio - 200802201747
                    break; //incluido - eduardo sertorio - 200802201747
                default: // caso venha string vazio ("") tambem considerar como nulo - eduardo sertorio - 200802201810
                    retorno = BusinessEntity.Enum.TipoLiquidacao.Normal;
                    break;
            }
            return retorno;
        }

        ///<sumary>
        /// Converte Tipo de Liquidacao de Enum para String
        /// Data: 17/12/2007
        /// Autor: Eduarddo Sertorio
        /// Observacoes: Criacao
        /// 
        /// Data : 20/02/2008
        /// Autor: Eduarddo Sertorio
        /// Obs. : Revisao
        ///<sumary>
        public static string EnumToString(BusinessEntity.Enum.TipoLiquidacao value)
        {
            string retorno = null;
            switch (value)
            {
                case BusinessEntity.Enum.TipoLiquidacao.Custodiante:
                    retorno = "C"; 
                    break;
                case BusinessEntity.Enum.TipoLiquidacao.Normal:
                    retorno = null;
                    break;
                default:
                    retorno = null; //incluido - eduardo sertorio - 200802201753
                    break;
            }
            return retorno;
        }

        ///<sumary>
        /// Converte Tipo de Ordem de int para Enum
        /// Data: 10/01/2008
        /// Autor: Eduarddo Sertorio
        /// Observacoes: Criacao do enum
        ///<sumary>
        public static BusinessEntity.Enum.TipoOrdem IntToEnum(int value)
        {
            BusinessEntity.Enum.TipoOrdem retorno = 0;

            switch (value)
            {
                case 1:
                    retorno = BusinessEntity.Enum.TipoOrdem.Mercado;
                    break;
                case 2:
                    retorno = BusinessEntity.Enum.TipoOrdem.Casada;
                    break;
                case 3:
                    retorno = BusinessEntity.Enum.TipoOrdem.Administrada;
                    break;
                case 4:
                    retorno = BusinessEntity.Enum.TipoOrdem.Discricionaria;
                    break;
                case 5:
                    retorno = BusinessEntity.Enum.TipoOrdem.Limitada;
                    break;
                case 6:
                    retorno = BusinessEntity.Enum.TipoOrdem.Financiamento;
                    break;
                case 7:
                    retorno = BusinessEntity.Enum.TipoOrdem.OnStop;
                    break;
                //default:
                //    retorno = null;
                //    break;
            }
            return retorno;
        }

        ///<sumary>
        /// Converte Tipo de Ordem de Enum para Int
        /// Data: 10/01/2008
        /// Autor: Eduarddo Sertorio
        /// Observacoes: Criacao do enum
        ///<sumary>
        public static int EnumToInt(BusinessEntity.Enum.TipoOrdem value)
        {
            int retorno = 0;
            switch (value)
            {
                case BusinessEntity.Enum.TipoOrdem.Mercado:
                    retorno = 1;
                    break;
                case BusinessEntity.Enum.TipoOrdem.Casada:
                    retorno = 2;
                    break;
                case BusinessEntity.Enum.TipoOrdem.Administrada:
                    retorno = 3;
                    break;
                case BusinessEntity.Enum.TipoOrdem.Discricionaria:
                    retorno = 4;
                    break;
                case BusinessEntity.Enum.TipoOrdem.Limitada:
                    retorno = 5;
                    break;
                case BusinessEntity.Enum.TipoOrdem.Financiamento:
                    retorno = 6;
                    break;
                case BusinessEntity.Enum.TipoOrdem.OnStop:
                    retorno = 7;
                    break;
                //default:
                //    retorno = null;
                //    break;
            }
            return retorno;
        }

        /// <summary>
        /// EnumToInt que aceita e trata nulo
        /// Autor: Eduardo Sertorio
        /// Data: 10/01/2008
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static int? EnumToInt(BusinessEntity.Enum.TipoOrdem? value)
        {
            if (value.HasValue)
                return EnumToInt(value.Value);
            else
                return null;
        }

        /// <summary>
        /// Converte codigo TP_ORDEM inteiro para lista de enum TipoOrdem
        /// Autor: Eduardo Sertorio
        /// Data: 10/01/2008
        /// 
        /// Autor: Eduardo Sertorio
        /// Data : 20/02/2008
        /// Obs. : Revisao
        /// </summary>
        /// <param name="intTipoOrdem"></param>
        /// <returns></returns>
        public static List<BusinessEntity.Enum.TipoOrdem> IntToListEnumTipoOrdem(int? intTipoOrdem)
        {
            List<BusinessEntity.Enum.TipoOrdem> listEnumTipoOrdem = new List<BusinessEntity.Enum.TipoOrdem>();
            if (intTipoOrdem.HasValue)
            {
                int intTipoOrdem1 = 0;
                int intTipoOrdem2 = 0;

                if (intTipoOrdem.ToString().Length >= 1) //um digito
                    Int32.TryParse(intTipoOrdem.ToString().Substring(0, 1).ToString(), out intTipoOrdem1);

                if (intTipoOrdem.ToString().Length == 2) //dois digitos
                    Int32.TryParse(intTipoOrdem.ToString().Substring(1, 1).ToString(), out intTipoOrdem2);

                if (intTipoOrdem1 != 0)
                    listEnumTipoOrdem.Add(IntToEnum(intTipoOrdem1));

                if (intTipoOrdem2 != 0)
                    listEnumTipoOrdem.Add(IntToEnum(intTipoOrdem2));
            }
            return listEnumTipoOrdem;
        }

        /// <summary>
        /// Converte codigo TP_ORDEM inteiro para lista de enum TipoOrdem
        /// Autor: Eduardo Sertorio
        /// Data: 10/01/2008
        /// 
        /// Autor: Eduardo Sertorio
        /// Data : 20/02/2008
        /// Obs. : Correção para gerar sempre combinacao com menor valor numerico ou nulo se for zero (nada selecionado)
        /// </summary>
        /// <param name="intTipoOrdem"></param>
        /// <returns></returns>
        public static int? ListEnumTipoOrdemToInt(List<BusinessEntity.Enum.TipoOrdem> listTipoOrdem)
        {
            int? response = null;
            int iTipoOrdem1 = 0; //alterado - eduardo sertorio - 200802202115
            int iTipoOrdem2 = 0; //alterado - eduardo sertorio - 200802202115
            int iTipoOrdem3 = 0;

            if ((listTipoOrdem.Count < 1) || (listTipoOrdem.Count > 2)) //alterado - eduardo sertorio - 200802202115
            {
                response = null;
            }
            else
            {
                if (listTipoOrdem.Count >= 1)
                    iTipoOrdem1 = EnumToInt(listTipoOrdem[0]);

                if (listTipoOrdem.Count == 2)
                    iTipoOrdem2 = EnumToInt(listTipoOrdem[1]);

                //alterado - eduardo sertorio - 200802202102
                if ((iTipoOrdem1 + iTipoOrdem2) != 0)
                {
                    if (iTipoOrdem1 > iTipoOrdem2)
                    {
                        iTipoOrdem3 = iTipoOrdem2; //alterado - eduardo sertorio - 200802202115
                        iTipoOrdem2 = iTipoOrdem1; //alterado - eduardo sertorio - 200802202115
                        iTipoOrdem1 = iTipoOrdem3;
                    }

                    response = iTipoOrdem1 * 10 + iTipoOrdem2;
                }
                else
                {
                    response = null;
                }
            }

            return response;
        }

        /// <summary>
        /// Método CancelarOrdemDistribuida
        /// Author:APSilva
        /// Data:26/08/2008
        /// OBS: Cancelamento de Ordem Distribuida
        /// </summary>
        public void CancelarOrdemDistribuida(BusinessEntity.Parameter.CancelarOrdemDistribuida cancelarOrdemDistribuida)
        {
            BusinessEntity.Resultado resultado = null;
        
            cancelarOrdemDistribuida.TipoDistribuicao = (cancelarOrdemDistribuida.NumeroConjunto > 0) ? "L" : "S";
            ResourceAccess.Ordem response = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();
            resultado = response.CancelarOrdemDistribuida(cancelarOrdemDistribuida);

            if (!resultado.Sucesso)
                TratarExcecoes(resultado);
        }

        public void CancelarOrdemDistribuida(List<BusinessEntity.Parameter.CancelarOrdemDistribuida> cancelarOrdemDistribuida)
        {
            BusinessLogic.Negocio validarEstadoSistema = new Negocio();
            validarEstadoSistema.ValidarEstadoSistema(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.ModuloChamador.ControleOrdens);

            foreach (BusinessEntity.Parameter.CancelarOrdemDistribuida parameter in cancelarOrdemDistribuida)
            {
                this.CancelarOrdemDistribuida(parameter);
            }
        }

        public List<BusinessEntity.OrdemDistribuidaResultado> CancelarOrdensDistribuidas(List<BusinessEntity.OrdemDistribuida> request)
        {
            BusinessEntity.Resultado resultado = null;
            ResourceAccess.Ordem raOrdem = null;
            BusinessEntity.OrdemDistribuidaResultado ordemDistribuicaoResultado = null;
            BusinessEntity.Parameter.CancelarOrdemDistribuida cancelarOrdem = null;
            List<BusinessEntity.OrdemDistribuidaResultado> retorno = null;
            string resourceKeyOut = null;
            string errorMessage = null;

            BusinessLogic.Negocio validarEstadoSistema = new Negocio();
            validarEstadoSistema.ValidarEstadoSistema(Sinacor.Servico.Bovespa.Ordens.BusinessEntity.Enum.ModuloChamador.ControleOrdens);

            raOrdem = new ResourceAccess.Ordem();
            retorno = new List<BusinessEntity.OrdemDistribuidaResultado>();

            foreach (BusinessEntity.OrdemDistribuida item in request)
            {
                cancelarOrdem = new BusinessEntity.Parameter.CancelarOrdemDistribuida();
                cancelarOrdem.Bolsa = item.Bolsa;
                cancelarOrdem.CodigoBroker = item.CodigoBroker;
                cancelarOrdem.CodigoFilhote = item.CodigoFilhote;
                cancelarOrdem.DataOrdem = item.DataOrdem;
                cancelarOrdem.DataPregao = item.DataPregao;
                cancelarOrdem.NaturezaOperacao = item.NaturezaOperacao;
                cancelarOrdem.NumeroConjunto = item.NumeroConjunto;
                cancelarOrdem.NumeroNegocio = item.NumeroNegocio;
                cancelarOrdem.NumeroOrdem = item.NumeroOrdem;
                cancelarOrdem.NumeroOrdemSubSequencia = item.NumeroOrdemSubSequencia;
                cancelarOrdem.TipoCancelamento = item.TipoCancelamento;
                cancelarOrdem.TipoDistribuicao = item.TipoDistribuicao;
                cancelarOrdem.Titulo = item.Titulo;

                if (item.NumeroNegocio > 0)
                {
                    cancelarOrdem.TipoDistribuicao = "N";
                }
                else if (item.NumeroConjunto > 0)
                {
                    cancelarOrdem.TipoDistribuicao = "L";
                }
                else
                {
                    cancelarOrdem.TipoDistribuicao = "S";
                }

                resultado = raOrdem.CancelarOrdemDistribuida(cancelarOrdem);

                ordemDistribuicaoResultado = new BusinessEntity.OrdemDistribuidaResultado();
                ordemDistribuicaoResultado.Identificador = item.Identificador;
                ordemDistribuicaoResultado.Sucesso = resultado.Sucesso;
                ordemDistribuicaoResultado.Erro = new ValidationError();

                if (resultado.CodigoErro == -1)
                {
                    resultado.CodigoErro = ERRO_ORDEM_DISTRIBUIDA_CANCELAMENTO_2;
                }

                ordemDistribuicaoResultado.Erro.ErrorNumber = resultado.CodigoErro;

                if (!String.IsNullOrEmpty(resultado.Argumentos))
                {
                    ordemDistribuicaoResultado.Erro.Parameters = ErrorMessage.ConvertXmlArgumentsToParameters(resultado.Argumentos);

                    errorMessage = ErrorMessage.RetrieveErrorMessage(resultado.CodigoErro, out resourceKeyOut, ordemDistribuicaoResultado.Erro.Parameters.ToArray());
                }
                else
                {
                    errorMessage = ErrorMessage.RetrieveErrorMessage(resultado.CodigoErro, out resourceKeyOut);
                }

                ordemDistribuicaoResultado.Erro.ErrorMessage = errorMessage;
                ordemDistribuicaoResultado.Erro.ResourceKey = resourceKeyOut;

                retorno.Add(ordemDistribuicaoResultado);
            }

            return retorno;
        }

        private void TratarExcecoes(BusinessEntity.Resultado request)
        {
            List<Object> _params;

            if (!String.IsNullOrEmpty(request.Argumentos))
            {
                _params = ErrorMessage.ConvertXmlArgumentsToParameters(request.Argumentos);

                throw new BusinessException(request.CodigoErro, _params.ToArray());
            }
            else
            {
                throw new BusinessException(request.CodigoErro);
            }
        }

        /// <summary>
        /// Método ConsultarOrdemDistribuida
        /// Author: APSilva
        /// Data:26/08/2008
        /// </summary>
        public List<BusinessEntity.Ordem> ConsultarOrdemDistribuida(BusinessEntity.Parameter.ConsultarOrdemDistribuida ordem)
        {
            if (ordem.ApelidoCliente != null)
            {
                Sinacor.Servico.Bovespa.Cliente.BusinessEntity.Cliente cliente = null;
                cliente = (new Sinacor.Servico.Bovespa.Cliente.ResourceAccess.Cliente()).ConsultarPorApelido(ordem.ApelidoCliente.ToString());
                if (cliente == null)
                {
                    ValidationException ex = new ValidationException();
                    ex.AddError(ERRO_CLIENTENAOENCONTRADO);
                    throw ex;
                }
            }

            ResourceAccess.Ordem response = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();
            return response.ConsultarOrdemDistribuida(ordem);
        }

        public List<BusinessEntity.Ordem> ConsultarOrdem(BusinessEntity.Parameter.ConsultarOrdem pConsultarOrdem)
        {
            ResourceAccess.Ordem consultar = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();
            return consultar.ConsultarOrdem(pConsultarOrdem);

        }
        
        /// <summary>
        /// Fecha a ordem
        /// </summary>
        /// <param name="pFecharOrdem"></param>
        public void FecharOrdem(List<BusinessEntity.Parameter.FecharOrdem> pFecharOrdem){
            ResourceAccess.Ordem objRaOrdem = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();

            for(int i=0; i<pFecharOrdem.Count; i++){
                objRaOrdem.FecharOrdem(pFecharOrdem[i]);
            }
        }
        
        public List<BusinessEntity.Justificativa> ConsultarJustificativaPadrao(){
            ResourceAccess.Ordem objRaOrdem = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();
            
            return objRaOrdem.ConsultarJustificativaPadrao();
        }
        
        public List<BusinessEntity.OrdemInconsistencia> ConsultarOrdemInconsistencia(BusinessEntity.Parameter.ConsultarOrdemInconsistencia pConsultarOrdemInconsistencia){
            ResourceAccess.Ordem objRaOrdem = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();
            
            return objRaOrdem.ConsultarOrdemInconsistencia(pConsultarOrdemInconsistencia);
        }

        #region ConsultarOrdemDistribuicaoOrdemOperador
        /// <summary>
        /// Método: ConsultarOrdemDistribuicaoOrdemOperador
        /// Autor: Ptruiz.gp
        /// Data: 2008.10.27
        /// </summary>
        /// <param name="pConsultarOrdemDistribuicaoOrdemOperador">BusinessEntity.Parameter.ConsultarOrdemDistribuicaoOrdemOperador</param>
        /// <returns>List(Business.Ordem)</returns>
        public List<BusinessEntity.Ordem> ConsultarOrdemDistribuicaoOrdemOperador(BusinessEntity.Parameter.ConsultarOrdemDistribuicaoOrdemOperador pConsultarOrdemDistribuicaoOrdemOperador)
        {
            ResourceAccess.Ordem RaOrdem = new Sinacor.Servico.Bovespa.Ordens.ResourceAccess.Ordem();
            return RaOrdem.ConsultarOrdemDistribuicaoOrdemOperador(pConsultarOrdemDistribuicaoOrdemOperador);
        }
        #endregion
    }
}
